kepler.gl
Version:
kepler.gl is a webgl based application to visualize large scale location data in the browser
1,219 lines (1,077 loc) • 123 kB
JavaScript
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = exports.colorMaker = exports.layerColors = exports.OVERLAY_TYPE = void 0;
var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
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 _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
var _window = require("global/window");
var _keymirror = _interopRequireDefault(require("keymirror"));
var _extensions = require("@deck.gl/extensions");
var _core = require("@deck.gl/core");
var _layers = require("@deck.gl/layers");
var _defaultLayerIcon = _interopRequireDefault(require("./default-layer-icon"));
var _layerUpdate = require("./layer-update");
var _defaultSettings = require("../constants/default-settings");
var _colorRanges = require("../constants/color-ranges");
var _customColorRanges = require("../constants/custom-color-ranges");
var _layerFactory = require("./layer-factory");
var _utils = require("../utils/utils");
var _dataUtils = require("../utils/data-utils");
var _dataScaleUtils = require("../utils/data-scale-utils");
var _colorUtils = require("../utils/color-utils");
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 _marked =
/*#__PURE__*/
_regenerator["default"].mark(generateColor);
/**
* Approx. number of points to sample in a large data set
* @type {number}
*/
var MAX_SAMPLE_SIZE = 5000;
var dataFilterExtension = new _extensions.DataFilterExtension({
filterSize: _defaultSettings.MAX_GPU_FILTERS
});
var identity = function identity(d) {
return d;
};
var OVERLAY_TYPE = (0, _keymirror["default"])({
deckgl: null,
mapboxgl: null
});
exports.OVERLAY_TYPE = OVERLAY_TYPE;
var layerColors = Object.values(_customColorRanges.DataVizColors).map(_colorUtils.hexToRgb);
exports.layerColors = layerColors;
function generateColor() {
var index;
return _regenerator["default"].wrap(function generateColor$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
index = 0;
case 1:
if (!(index < layerColors.length + 1)) {
_context.next = 7;
break;
}
if (index === layerColors.length) {
index = 0;
}
_context.next = 5;
return layerColors[index++];
case 5:
_context.next = 1;
break;
case 7:
case "end":
return _context.stop();
}
}
}, _marked);
}
var colorMaker = generateColor();
exports.colorMaker = colorMaker;
var defaultGetFieldValue = function defaultGetFieldValue(field, d) {
return d[field.tableFieldIndex - 1];
};
var Layer =
/*#__PURE__*/
function () {
function Layer() {
var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
(0, _classCallCheck2["default"])(this, Layer);
this.id = props.id || (0, _utils.generateHashId)(6); // meta
this.meta = {}; // visConfigSettings
this.visConfigSettings = {};
this.config = this.getDefaultLayerConfig(_objectSpread({
columns: this.getLayerColumns()
}, props));
}
(0, _createClass2["default"])(Layer, [{
key: "getDefaultLayerConfig",
value: function getDefaultLayerConfig() {
var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
return {
dataId: props.dataId || null,
label: props.label || 'new layer',
color: props.color || colorMaker.next().value,
columns: props.columns || null,
isVisible: props.isVisible || false,
isConfigActive: props.isConfigActive || false,
highlightColor: props.highlightColor || [252, 242, 26, 255],
// TODO: refactor this into separate visual Channel config
// color by field, domain is set by filters, field, scale type
colorField: null,
colorDomain: [0, 1],
colorScale: _defaultSettings.SCALE_TYPES.quantile,
// color by size, domain is set by filters, field, scale type
sizeDomain: [0, 1],
sizeScale: _defaultSettings.SCALE_TYPES.linear,
sizeField: null,
visConfig: {},
textLabel: [_layerFactory.DEFAULT_TEXT_LABEL],
colorUI: {
color: _layerFactory.DEFAULT_COLOR_UI,
colorRange: _layerFactory.DEFAULT_COLOR_UI
},
animation: {
enabled: false
}
};
}
/**
* Get the description of a visualChannel config
* @param key
* @returns {{label: string, measure: (string|string)}}
*/
}, {
key: "getVisualChannelDescription",
value: function getVisualChannelDescription(key) {
// e.g. label: Color, measure: Vehicle Type
return {
label: this.visConfigSettings[this.visualChannels[key].range].label,
measure: this.config[this.visualChannels[key].field] ? this.config[this.visualChannels[key].field].name : this.visualChannels[key].defaultMeasure
};
}
/**
* Assign a field to layer column, return column config
* @param key - Column Key
* @param field - Selected field
* @returns {{}} - Column config
*/
}, {
key: "assignColumn",
value: function assignColumn(key, field) {
// field value could be null for optional columns
var update = field ? {
value: field.name,
fieldIdx: field.tableFieldIndex - 1
} : {
value: null,
fieldIdx: -1
};
return _objectSpread({}, this.config.columns, (0, _defineProperty2["default"])({}, key, _objectSpread({}, this.config.columns[key], {}, update)));
}
/**
* Assign a field pair to column config, return column config
* @param key - Column Key
* @param pair - field Pair
* @returns {{}} - Column config
*/
}, {
key: "assignColumnPairs",
value: function assignColumnPairs(key, pair) {
var _objectSpread3;
if (!this.columnPairs || !this.columnPairs[key]) {
// should not end in this state
return this.config.columns;
}
var _this$columnPairs$key = this.columnPairs[key],
partnerKey = _this$columnPairs$key.pair,
fieldPairKey = _this$columnPairs$key.fieldPairKey;
var partnerFieldPairKey = this.columnPairs[partnerKey].fieldPairKey;
return _objectSpread({}, this.config.columns, (_objectSpread3 = {}, (0, _defineProperty2["default"])(_objectSpread3, key, pair[fieldPairKey]), (0, _defineProperty2["default"])(_objectSpread3, partnerKey, pair[partnerFieldPairKey]), _objectSpread3));
}
/**
* Calculate a radius zoom multiplier to render points, so they are visible in all zoom level
* @param mapState
* @param mapState.zoom - actual zoom
* @param mapState.zoomOffset - zoomOffset when render in the plot container for export image
* @returns {number}
*/
}, {
key: "getZoomFactor",
value: function getZoomFactor(_ref) {
var zoom = _ref.zoom,
_ref$zoomOffset = _ref.zoomOffset,
zoomOffset = _ref$zoomOffset === void 0 ? 0 : _ref$zoomOffset;
return Math.pow(2, Math.max(14 - zoom + zoomOffset, 0));
}
/**
* Calculate a elevation zoom multiplier to render points, so they are visible in all zoom level
* @param mapState
* @param mapState.zoom - actual zoom
* @param mapState.zoomOffset - zoomOffset when render in the plot container for export image
* @returns {number}
*/
}, {
key: "getElevationZoomFactor",
value: function getElevationZoomFactor(_ref2) {
var zoom = _ref2.zoom,
_ref2$zoomOffset = _ref2.zoomOffset,
zoomOffset = _ref2$zoomOffset === void 0 ? 0 : _ref2$zoomOffset;
return Math.pow(2, Math.max(8 - zoom + zoomOffset, 0));
}
}, {
key: "formatLayerData",
value: function formatLayerData(datasets, filteredIndex) {
return {};
}
}, {
key: "renderLayer",
value: function renderLayer() {
return [];
}
}, {
key: "getHoverData",
value: function getHoverData(object) {
if (!object) {
return null;
} // by default, each entry of layerData should have a data property points
// to the original item in the allData array
// each layer can implement its own getHoverData method
return object.data;
}
/**
* When change layer type, try to copy over layer configs as much as possible
* @param configToCopy - config to copy over
* @param visConfigSettings - visConfig settings of config to copy
*/
}, {
key: "assignConfigToLayer",
value: function assignConfigToLayer(configToCopy, visConfigSettings) {
var _this = this;
// don't deep merge visualChannel field
// don't deep merge color range, reversed: is not a key by default
var shallowCopy = ['colorRange', 'strokeColorRange'].concat(Object.values(this.visualChannels).map(function (v) {
return v.field;
})); // don't copy over domain and animation
var notToCopy = ['animation'].concat(Object.values(this.visualChannels).map(function (v) {
return v.domain;
})); // if range is for the same property group copy it, otherwise, not to copy
Object.values(this.visualChannels).forEach(function (v) {
if (configToCopy.visConfig[v.range] && visConfigSettings[v.range].group !== _this.visConfigSettings[v.range].group) {
notToCopy.push(v.range);
}
}); // don't copy over visualChannel range
var currentConfig = this.config;
var copied = this.copyLayerConfig(currentConfig, configToCopy, {
shallowCopy: shallowCopy,
notToCopy: notToCopy
});
this.updateLayerConfig(copied); // validate visualChannel field type and scale types
Object.keys(this.visualChannels).forEach(function (channel) {
_this.validateVisualChannel(channel);
});
}
/*
* Recursively copy config over to an empty layer
* when received saved config, or copy config over from a different layer type
* make sure to only copy over value to existing keys
* @param {object} currentConfig - existing config to be override
* @param {object} configToCopy - new Config to copy over
* @param {string[]} shallowCopy - array of properties to not to be deep copied
* @param {string[]} notToCopy - array of properties not to copy
* @returns {object} - copied config
*/
}, {
key: "copyLayerConfig",
value: function copyLayerConfig(currentConfig, configToCopy) {
var _this2 = this;
var _ref3 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
_ref3$shallowCopy = _ref3.shallowCopy,
shallowCopy = _ref3$shallowCopy === void 0 ? [] : _ref3$shallowCopy,
_ref3$notToCopy = _ref3.notToCopy,
notToCopy = _ref3$notToCopy === void 0 ? [] : _ref3$notToCopy;
var copied = {};
Object.keys(currentConfig).forEach(function (key) {
if ((0, _utils.isPlainObject)(currentConfig[key]) && (0, _utils.isPlainObject)(configToCopy[key]) && !shallowCopy.includes(key) && !notToCopy.includes(key)) {
// recursively assign object value
copied[key] = _this2.copyLayerConfig(currentConfig[key], configToCopy[key], {
shallowCopy: shallowCopy,
notToCopy: notToCopy
});
} else if ((0, _dataUtils.notNullorUndefined)(configToCopy[key]) && !notToCopy.includes(key)) {
// copy
copied[key] = configToCopy[key];
} else {
// keep existing
copied[key] = currentConfig[key];
}
});
return copied;
}
}, {
key: "registerVisConfig",
value: function registerVisConfig(layerVisConfigs) {
var _this3 = this;
Object.keys(layerVisConfigs).forEach(function (item) {
if (typeof item === 'string' && _layerFactory.LAYER_VIS_CONFIGS[layerVisConfigs[item]]) {
// if assigned one of default LAYER_CONFIGS
_this3.config.visConfig[item] = _layerFactory.LAYER_VIS_CONFIGS[layerVisConfigs[item]].defaultValue;
_this3.visConfigSettings[item] = _layerFactory.LAYER_VIS_CONFIGS[layerVisConfigs[item]];
} else if (['type', 'defaultValue'].every(function (p) {
return layerVisConfigs[item].hasOwnProperty(p);
})) {
// if provided customized visConfig, and has type && defaultValue
// TODO: further check if customized visConfig is valid
_this3.config.visConfig[item] = layerVisConfigs[item].defaultValue;
_this3.visConfigSettings[item] = layerVisConfigs[item];
}
});
}
}, {
key: "getLayerColumns",
value: function getLayerColumns() {
var required = this.requiredLayerColumns.reduce(function (accu, key) {
return _objectSpread({}, accu, (0, _defineProperty2["default"])({}, key, {
value: null,
fieldIdx: -1
}));
}, {});
var optional = this.optionalColumns.reduce(function (accu, key) {
return _objectSpread({}, accu, (0, _defineProperty2["default"])({}, key, {
value: null,
fieldIdx: -1,
optional: true
}));
}, {});
return _objectSpread({}, required, {}, optional);
}
}, {
key: "updateLayerConfig",
value: function updateLayerConfig(newConfig) {
this.config = _objectSpread({}, this.config, {}, newConfig);
return this;
}
}, {
key: "updateLayerVisConfig",
value: function updateLayerVisConfig(newVisConfig) {
this.config.visConfig = _objectSpread({}, this.config.visConfig, {}, newVisConfig);
return this;
}
}, {
key: "updateLayerColorUI",
value: function updateLayerColorUI(prop, newConfig) {
var _this$config = this.config,
previous = _this$config.colorUI,
visConfig = _this$config.visConfig;
if (!(0, _utils.isPlainObject)(newConfig) || typeof prop !== 'string') {
return this;
}
var colorUIProp = Object.entries(newConfig).reduce(function (accu, _ref4) {
var _ref5 = (0, _slicedToArray2["default"])(_ref4, 2),
key = _ref5[0],
value = _ref5[1];
return _objectSpread({}, accu, (0, _defineProperty2["default"])({}, key, (0, _utils.isPlainObject)(accu[key]) && (0, _utils.isPlainObject)(value) ? _objectSpread({}, accu[key], {}, value) : value));
}, previous[prop] || _layerFactory.DEFAULT_COLOR_UI);
var colorUI = _objectSpread({}, previous, (0, _defineProperty2["default"])({}, prop, colorUIProp));
this.updateLayerConfig({
colorUI: colorUI
}); // if colorUI[prop] is colorRange
var isColorRange = visConfig[prop] && visConfig[prop].colors;
if (isColorRange) {
this.updateColorUIByColorRange(newConfig, prop);
this.updateColorRangeByColorUI(newConfig, previous, prop);
this.updateCustomPalette(newConfig, previous, prop);
}
return this;
}
}, {
key: "updateCustomPalette",
value: function updateCustomPalette(newConfig, previous, prop) {
if (!newConfig.colorRangeConfig || !newConfig.colorRangeConfig.custom) {
return;
}
var _this$config2 = this.config,
colorUI = _this$config2.colorUI,
visConfig = _this$config2.visConfig;
if (!visConfig[prop]) return;
var colors = visConfig[prop].colors;
var customPalette = _objectSpread({}, colorUI[prop].customPalette, {
name: 'Custom Palette',
colors: (0, _toConsumableArray2["default"])(colors)
});
this.updateLayerConfig({
colorUI: _objectSpread({}, colorUI, (0, _defineProperty2["default"])({}, prop, _objectSpread({}, colorUI[prop], {
customPalette: customPalette
})))
});
}
/**
* if open dropdown and prop is color range
* Automatically set colorRangeConfig's step and reversed
* @param {*} newConfig
* @param {*} prop
*/
}, {
key: "updateColorUIByColorRange",
value: function updateColorUIByColorRange(newConfig, prop) {
if (typeof newConfig.showDropdown !== 'number') return;
var _this$config3 = this.config,
colorUI = _this$config3.colorUI,
visConfig = _this$config3.visConfig;
this.updateLayerConfig({
colorUI: _objectSpread({}, colorUI, (0, _defineProperty2["default"])({}, prop, _objectSpread({}, colorUI[prop], {
colorRangeConfig: _objectSpread({}, colorUI[prop].colorRangeConfig, {
steps: visConfig[prop].colors.length,
reversed: Boolean(visConfig[prop].reversed)
})
})))
});
}
}, {
key: "updateColorRangeByColorUI",
value: function updateColorRangeByColorUI(newConfig, previous, prop) {
// only update colorRange if changes in UI is made to 'reversed', 'steps' or steps
var shouldUpdate = newConfig.colorRangeConfig && ['reversed', 'steps'].some(function (key) {
return newConfig.colorRangeConfig.hasOwnProperty(key) && newConfig.colorRangeConfig[key] !== (previous[prop] || _layerFactory.DEFAULT_COLOR_UI).colorRangeConfig[key];
});
if (!shouldUpdate) return;
var _this$config4 = this.config,
colorUI = _this$config4.colorUI,
visConfig = _this$config4.visConfig;
var _colorUI$prop$colorRa = colorUI[prop].colorRangeConfig,
steps = _colorUI$prop$colorRa.steps,
reversed = _colorUI$prop$colorRa.reversed;
var colorRange = visConfig[prop]; // find based on step or reversed
var update;
if (newConfig.colorRangeConfig.hasOwnProperty('steps')) {
var group = (0, _colorUtils.getColorGroupByName)(colorRange);
if (group) {
var sameGroup = _colorRanges.COLOR_RANGES.filter(function (cr) {
return (0, _colorUtils.getColorGroupByName)(cr) === group;
});
update = sameGroup.find(function (cr) {
return cr.colors.length === steps;
});
if (update && colorRange.reversed) {
update = (0, _colorUtils.reverseColorRange)(true, update);
}
}
}
if (newConfig.colorRangeConfig.hasOwnProperty('reversed')) {
update = (0, _colorUtils.reverseColorRange)(reversed, update || colorRange);
}
if (update) {
this.updateLayerVisConfig((0, _defineProperty2["default"])({}, prop, update));
}
}
/**
* Check whether layer has all columns
*
* @param {object} layer
* @returns {boolean} yes or no
*/
}, {
key: "hasAllColumns",
value: function hasAllColumns() {
var columns = this.config.columns;
return columns && Object.values(columns).every(function (v) {
return Boolean(v.optional || v.value && v.fieldIdx > -1);
});
}
/**
* Check whether layer has data
*
* @param {object} layer
* @param {Array | Object} layerData
* @returns {boolean} yes or no
*/
}, {
key: "hasLayerData",
value: function hasLayerData(layerData) {
if (!layerData) {
return false;
}
return Boolean(layerData.data && layerData.data.length);
}
}, {
key: "isValidToSave",
value: function isValidToSave() {
return this.type && this.hasAllColumns();
}
}, {
key: "shouldRenderLayer",
value: function shouldRenderLayer(data) {
return this.type && this.config.isVisible && this.hasAllColumns() && this.hasLayerData(data) && typeof this.renderLayer === 'function';
}
}, {
key: "getVisChannelScale",
value: function getVisChannelScale(scale, domain, range, fixed) {
return _defaultSettings.SCALE_FUNC[fixed ? 'linear' : scale]().domain(domain).range(fixed ? domain : range);
}
}, {
key: "getPointsBounds",
value: function getPointsBounds(allData) {
var getPosition = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : identity;
// no need to loop through the entire dataset
// get a sample of data to calculate bounds
var sampleData = allData.length > MAX_SAMPLE_SIZE ? (0, _dataUtils.getSampleData)(allData, MAX_SAMPLE_SIZE) : allData;
var points = sampleData.map(getPosition);
var latBounds = (0, _dataUtils.getLatLngBounds)(points, 1, [-90, 90]);
var lngBounds = (0, _dataUtils.getLatLngBounds)(points, 0, [-180, 180]);
if (!latBounds || !lngBounds) {
return null;
}
return [lngBounds[0], latBounds[0], lngBounds[1], latBounds[1]];
}
}, {
key: "getChangedTriggers",
value: function getChangedTriggers(dataUpdateTriggers) {
var triggerChanged = (0, _layerUpdate.diffUpdateTriggers)(dataUpdateTriggers, this._oldDataUpdateTriggers);
this._oldDataUpdateTriggers = dataUpdateTriggers;
return triggerChanged;
}
}, {
key: "getEncodedChannelValue",
value: function getEncodedChannelValue(scale, data, field) {
var nullValue = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : _defaultSettings.NO_VALUE_COLOR;
var getValue = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : defaultGetFieldValue;
var type = field.type;
var value = getValue(field, data);
if (!(0, _dataUtils.notNullorUndefined)(value)) {
return nullValue;
}
var attributeValue;
if (type === _defaultSettings.ALL_FIELD_TYPES.timestamp) {
// shouldn't need to convert here
// scale Function should take care of it
attributeValue = scale(new Date(value));
} else {
attributeValue = scale(value);
}
if (!(0, _dataUtils.notNullorUndefined)(attributeValue)) {
attributeValue = nullValue;
}
return attributeValue;
}
}, {
key: "updateMeta",
value: function updateMeta(meta) {
this.meta = _objectSpread({}, this.meta, {}, meta);
}
}, {
key: "getDataUpdateTriggers",
value: function getDataUpdateTriggers(_ref6) {
var filteredIndex = _ref6.filteredIndex,
id = _ref6.id;
var columns = this.config.columns;
return _objectSpread({
getData: {
datasetId: id,
columns: columns,
filteredIndex: filteredIndex
},
getMeta: {
datasetId: id,
columns: columns
}
}, (this.config.textLabel || []).reduce(function (accu, tl, i) {
return _objectSpread({}, accu, (0, _defineProperty2["default"])({}, "getLabelCharacterSet-".concat(i), tl.field ? tl.field.name : null));
}, {}));
}
}, {
key: "updateData",
value: function updateData(datasets, oldLayerData) {
var layerDataset = datasets[this.config.dataId];
var allData = datasets[this.config.dataId].allData;
var getPosition = this.getPositionAccessor();
var dataUpdateTriggers = this.getDataUpdateTriggers(layerDataset);
var triggerChanged = this.getChangedTriggers(dataUpdateTriggers);
if (triggerChanged.getMeta) {
this.updateLayerMeta(allData, getPosition);
}
var data = [];
if (!triggerChanged.getData) {
// same data
data = oldLayerData.data;
} else {
data = this.calculateDataAttribute(layerDataset, getPosition);
}
return {
data: data,
triggerChanged: triggerChanged
};
}
/**
* helper function to update one layer domain when state.data changed
* if state.data change is due ot update filter, newFiler will be passed
* called by updateAllLayerDomainData
* @param {Object} dataset
* @param {Object} newFilter
* @returns {object} layer
*/
}, {
key: "updateLayerDomain",
value: function updateLayerDomain(datasets, newFilter) {
var _this4 = this;
var dataset = this.getDataset(datasets);
if (!dataset) {
return this;
}
Object.values(this.visualChannels).forEach(function (channel) {
var scale = channel.scale;
var scaleType = _this4.config[scale]; // ordinal domain is based on allData, if only filter changed
// no need to update ordinal domain
if (!newFilter || scaleType !== _defaultSettings.SCALE_TYPES.ordinal) {
var domain = channel.domain;
var updatedDomain = _this4.calculateLayerDomain(dataset, channel);
_this4.updateLayerConfig((0, _defineProperty2["default"])({}, domain, updatedDomain));
}
});
return this;
}
}, {
key: "getDataset",
value: function getDataset(datasets) {
return datasets[this.config.dataId];
}
/**
* Validate visual channel field and scales based on supported field & scale type
* @param channel
*/
}, {
key: "validateVisualChannel",
value: function validateVisualChannel(channel) {
this.validateFieldType(channel);
this.validateScale(channel);
}
/**
* Validate field type based on channelScaleType
*/
}, {
key: "validateFieldType",
value: function validateFieldType(channel) {
var visualChannel = this.visualChannels[channel];
var field = visualChannel.field,
channelScaleType = visualChannel.channelScaleType,
supportedFieldTypes = visualChannel.supportedFieldTypes;
if (this.config[field]) {
// if field is selected, check if field type is supported
var channelSupportedFieldTypes = supportedFieldTypes || _defaultSettings.CHANNEL_SCALE_SUPPORTED_FIELDS[channelScaleType];
if (!channelSupportedFieldTypes.includes(this.config[field].type)) {
// field type is not supported, set it back to null
// set scale back to default
this.updateLayerConfig((0, _defineProperty2["default"])({}, field, null));
}
}
}
/**
* Validate scale type based on aggregation
*/
}, {
key: "validateScale",
value: function validateScale(channel) {
var visualChannel = this.visualChannels[channel];
var scale = visualChannel.scale;
if (!scale) {
// visualChannel doesn't have scale
return;
}
var scaleOptions = this.getScaleOptions(channel); // check if current selected scale is
// supported, if not, change to default
if (!scaleOptions.includes(this.config[scale])) {
this.updateLayerConfig((0, _defineProperty2["default"])({}, scale, scaleOptions[0]));
}
}
/**
* Get scale options based on current field
* @param {string} channel
* @returns {string[]}
*/
}, {
key: "getScaleOptions",
value: function getScaleOptions(channel) {
var visualChannel = this.visualChannels[channel];
var field = visualChannel.field,
scale = visualChannel.scale,
channelScaleType = visualChannel.channelScaleType;
return this.config[field] ? _defaultSettings.FIELD_OPTS[this.config[field].type].scale[channelScaleType] : [this.getDefaultLayerConfig()[scale]];
}
}, {
key: "updateLayerVisualChannel",
value: function updateLayerVisualChannel(dataset, channel) {
var visualChannel = this.visualChannels[channel];
this.validateVisualChannel(channel); // calculate layer channel domain
var updatedDomain = this.calculateLayerDomain(dataset, visualChannel);
this.updateLayerConfig((0, _defineProperty2["default"])({}, visualChannel.domain, updatedDomain));
}
}, {
key: "calculateLayerDomain",
value: function calculateLayerDomain(dataset, visualChannel) {
var allData = dataset.allData,
filteredIndexForDomain = dataset.filteredIndexForDomain;
var defaultDomain = [0, 1];
var scale = visualChannel.scale;
var scaleType = this.config[scale];
var field = this.config[visualChannel.field];
if (!field) {
// if colorField or sizeField were set back to null
return defaultDomain;
}
if (!_defaultSettings.SCALE_TYPES[scaleType]) {
_window.console.error("scale type ".concat(scaleType, " not supported"));
return defaultDomain;
} // TODO: refactor to add valueAccessor to field
var fieldIdx = field.tableFieldIndex - 1;
var isTime = field.type === _defaultSettings.ALL_FIELD_TYPES.timestamp;
var valueAccessor = _dataUtils.maybeToDate.bind(null, isTime, fieldIdx, field.format);
var indexValueAccessor = function indexValueAccessor(i) {
return valueAccessor(allData[i]);
};
var sortFunction = (0, _dataUtils.getSortingFunction)(field.type);
switch (scaleType) {
case _defaultSettings.SCALE_TYPES.ordinal:
case _defaultSettings.SCALE_TYPES.point:
// do not recalculate ordinal domain based on filtered data
// don't need to update ordinal domain every time
return (0, _dataScaleUtils.getOrdinalDomain)(allData, valueAccessor);
case _defaultSettings.SCALE_TYPES.quantile:
return (0, _dataScaleUtils.getQuantileDomain)(filteredIndexForDomain, indexValueAccessor, sortFunction);
case _defaultSettings.SCALE_TYPES.log:
return (0, _dataScaleUtils.getLogDomain)(filteredIndexForDomain, indexValueAccessor);
case _defaultSettings.SCALE_TYPES.quantize:
case _defaultSettings.SCALE_TYPES.linear:
case _defaultSettings.SCALE_TYPES.sqrt:
default:
return (0, _dataScaleUtils.getLinearDomain)(filteredIndexForDomain, indexValueAccessor);
}
}
}, {
key: "isLayerHovered",
value: function isLayerHovered(objectInfo) {
return objectInfo && objectInfo.layer && objectInfo.picked && objectInfo.layer.props.id === this.id;
}
}, {
key: "getRadiusScaleByZoom",
value: function getRadiusScaleByZoom(mapState, fixedRadius) {
var radiusChannel = Object.values(this.visualChannels).find(function (vc) {
return vc.property === 'radius';
});
if (!radiusChannel) {
return 1;
}
var field = radiusChannel.field;
var fixed = fixedRadius === undefined ? this.config.visConfig.fixedRadius : fixedRadius;
var radius = this.config.visConfig.radius;
return fixed ? 1 : (this.config[field] ? 1 : radius) * this.getZoomFactor(mapState);
}
}, {
key: "shouldCalculateLayerData",
value: function shouldCalculateLayerData(props) {
var _this5 = this;
return props.some(function (p) {
return !_this5.noneLayerDataAffectingProps.includes(p);
});
}
}, {
key: "getBrushingExtensionProps",
value: function getBrushingExtensionProps(interactionConfig, brushingTarget) {
var brush = interactionConfig.brush;
return {
// brushing
autoHighlight: !brush.enabled,
brushingRadius: brush.config.size * 1000,
brushingTarget: brushingTarget || 'source',
brushingEnabled: brush.enabled
};
}
}, {
key: "getDefaultDeckLayerProps",
value: function getDefaultDeckLayerProps(_ref7) {
var idx = _ref7.idx,
gpuFilter = _ref7.gpuFilter,
mapState = _ref7.mapState;
return {
id: this.id,
idx: idx,
coordinateSystem: _core.COORDINATE_SYSTEM.LNGLAT,
pickable: true,
wrapLongitude: true,
parameters: {
depthTest: Boolean(mapState.dragRotate || this.config.visConfig.enable3d)
},
// visconfig
opacity: this.config.visConfig.opacity,
highlightColor: this.config.highlightColor,
// data filtering
extensions: [dataFilterExtension],
filterRange: gpuFilter.filterRange
};
}
}, {
key: "getDefaultHoverLayerProps",
value: function getDefaultHoverLayerProps() {
return {
id: "".concat(this.id, "-hovered"),
pickable: false,
wrapLongitude: true,
coordinateSystem: _core.COORDINATE_SYSTEM.LNGLAT
};
}
}, {
key: "renderTextLabelLayer",
value: function renderTextLabelLayer(_ref8, renderOpts) {
var _this6 = this;
var getPosition = _ref8.getPosition,
getPixelOffset = _ref8.getPixelOffset,
updateTriggers = _ref8.updateTriggers,
sharedProps = _ref8.sharedProps;
var data = renderOpts.data,
mapState = renderOpts.mapState;
var textLabel = this.config.textLabel;
return data.textLabels.reduce(function (accu, d, i) {
if (d.getText) {
accu.push(new _layers.TextLayer(_objectSpread({}, sharedProps, {
id: "".concat(_this6.id, "-label-").concat(textLabel[i].field.name),
data: data.data,
getText: d.getText,
getPosition: getPosition,
characterSet: d.characterSet,
getPixelOffset: getPixelOffset(textLabel[i]),
getSize: 1,
sizeScale: textLabel[i].size,
getTextAnchor: textLabel[i].anchor,
getAlignmentBaseline: textLabel[i].alignment,
getColor: textLabel[i].color,
parameters: {
// text will always show on top of all layers
depthTest: false
},
getFilterValue: data.getFilterValue,
updateTriggers: _objectSpread({}, updateTriggers, {
getText: textLabel[i].field.name,
getPixelOffset: _objectSpread({}, updateTriggers.getRadius, {
mapState: mapState,
anchor: textLabel[i].anchor,
alignment: textLabel[i].alignment
}),
getTextAnchor: textLabel[i].anchor,
getAlignmentBaseline: textLabel[i].alignment,
getColor: textLabel[i].color
})
})));
}
return accu;
}, []);
}
}, {
key: "layerIcon",
get: function get() {
return _defaultLayerIcon["default"];
}
}, {
key: "overlayType",
get: function get() {
return OVERLAY_TYPE.deckgl;
}
}, {
key: "type",
get: function get() {
return null;
}
}, {
key: "name",
get: function get() {
return this.type;
}
}, {
key: "isAggregated",
get: function get() {
return false;
}
}, {
key: "requiredLayerColumns",
get: function get() {
return [];
}
}, {
key: "optionalColumns",
get: function get() {
return [];
}
}, {
key: "noneLayerDataAffectingProps",
get: function get() {
return ['label', 'opacity', 'thickness', 'isVisible'];
}
}, {
key: "visualChannels",
get: function get() {
return {
color: {
property: 'color',
field: 'colorField',
scale: 'colorScale',
domain: 'colorDomain',
range: 'colorRange',
key: 'color',
channelScaleType: _defaultSettings.CHANNEL_SCALES.color
},
size: {
property: 'size',
field: 'sizeField',
scale: 'sizeScale',
domain: 'sizeDomain',
range: 'sizeRange',
key: 'size',
channelScaleType: _defaultSettings.CHANNEL_SCALES.size
}
};
}
/*
* Column pairs maps layer column to a specific field pairs,
* By default, it is set to null
*/
}, {
key: "columnPairs",
get: function get() {
return null;
}
/*
* Default point column pairs, can be used for point based layers: point, icon etc.
*/
}, {
key: "defaultPointColumnPairs",
get: function get() {
return {
lat: {
pair: 'lng',
fieldPairKey: 'lat'
},
lng: {
pair: 'lat',
fieldPairKey: 'lng'
}
};
}
/*
* Default link column pairs, can be used for link based layers: arc, line etc
*/
}, {
key: "defaultLinkColumnPairs",
get: function get() {
return {
lat0: {
pair: 'lng0',
fieldPairKey: 'lat'
},
lng0: {
pair: 'lat0',
fieldPairKey: 'lng'
},
lat1: {
pair: 'lng1',
fieldPairKey: 'lat'
},
lng1: {
pair: 'lat1',
fieldPairKey: 'lng'
}
};
}
/**
* Return a React component for to render layer instructions in a modal
* @returns {object} - an object
* @example
* return {
* id: 'iconInfo',
* template: IconInfoModal,
* modalProps: {
* title: 'How to draw icons'
* };
* }
*/
}, {
key: "layerInfoModal",
get: function get() {
return null;
}
/*
* Given a dataset, automatically find props to create layer based on it
* and return the props and previous found layers.
* By default, no layers will be found
*/
}], [{
key: "findDefaultLayerProps",
value: function findDefaultLayerProps(dataset, foundLayers) {
return {
props: [],
foundLayers: foundLayers
};
}
/**
* Given a array of preset required column names
* found field that has the same name to set as layer column
*
* @param {object} defaultFields
* @param {object[]} allFields
* @returns {object[] | null} all possible required layer column pairs
*/
}, {
key: "findDefaultColumnField",
value: function findDefaultColumnField(defaultFields, allFields) {
// find all matched fields for each required col
var requiredColumns = Object.keys(defaultFields).reduce(function (prev, key) {
var requiredFields = allFields.filter(function (f) {
return f.name === defaultFields[key] || defaultFields[key].includes(f.name);
});
prev[key] = requiredFields.length ? requiredFields.map(function (f) {
return {
value: f.name,
fieldIdx: f.tableFieldIndex - 1
};
}) : null;
return prev;
}, {});
if (!Object.values(requiredColumns).every(Boolean)) {
// if any field missing, return null
return null;
}
return this.getAllPossibleColumnParis(requiredColumns);
}
}, {
key: "getAllPossibleColumnParis",
value: function getAllPossibleColumnParis(requiredColumns) {
// for multiple matched field for one required column, return multiple
// combinations, e. g. if column a has 2 matched, column b has 3 matched
// 6 possible column pairs will be returned
var allKeys = Object.keys(requiredColumns);
var pointers = allKeys.map(function (k, i) {
return i === allKeys.length - 1 ? -1 : 0;
});
var countPerKey = allKeys.map(function (k) {
return requiredColumns[k].length;
});
var pairs = [];
/* eslint-disable no-loop-func */
while (incrementPointers(pointers, countPerKey, pointers.length - 1)) {
var newPair = pointers.reduce(function (prev, cuur, i) {
prev[allKeys[i]] = requiredColumns[allKeys[i]][cuur];
return prev;
}, {});
pairs.push(newPair);
}
/* eslint-enable no-loop-func */
// recursively increment pointers
function incrementPointers(pts, counts, index) {
if (index === 0 && pts[0] === counts[0] - 1) {
// nothing to increment
return false;
}
if (pts[index] + 1 < counts[index]) {
pts[index] = pts[index] + 1;
return true;
}
pts[index] = 0;
return incrementPointers(pts, counts, index - 1);
}
return pairs;
}
}, {
key: "hexToRgb",
value: function hexToRgb(c) {
return (0, _colorUtils.hexToRgb)(c);
}
}]);
return Layer;
}();
exports["default"] = Layer;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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