@carto/kepler.gl 0.1.0-alpha.1 → 0.1.0-next.0

package/dist/utils/gl-utils.d.ts

@@ -1 +1 @@
-export declare function setLayerBlending(gl: any, layerBlending: any): void;
+export declare function setLayerBlending(gl: any, layerBlending: any): void;

package/dist/utils/gl-utils.js

@@ -0,0 +1,43 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setLayerBlending = setLayerBlending;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _defaultSettings = require("../constants/default-settings");
+var _constants = require("@luma.gl/constants");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } // 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.
+var getGlConst = function getGlConst(d) {
+  return _constants.GL[d];
+};
+function setLayerBlending(gl, layerBlending) {
+  var blending = _defaultSettings.LAYER_BLENDINGS[layerBlending];
+  var blendFunc = blending.blendFunc,
+    blendEquation = blending.blendEquation;
+  gl.device.setParametersWebGL(_objectSpread((0, _defineProperty2["default"])({}, _constants.GL.BLEND, true), blendFunc ? {
+    blendFunc: blendFunc.map(getGlConst),
+    blendEquation: Array.isArray(blendEquation) ? blendEquation.map(getGlConst) : getGlConst(blendEquation)
+  } : {}));
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/utils/gpu-filter-utils.d.ts

@@ -1,28 +1,28 @@
-import { Filter } from 'reducers/vis-state-updaters';
-import { Field, GpuFilter } from './table-utils/kepler-table';
-/**
- * Set gpu mode based on current number of gpu filters exists
- */
-export declare function setFilterGpuMode(filter: Filter, filters: Filter[]): Filter;
-/**
- * Scan though all filters and assign gpu chanel to gpu filter
- */
-export declare function assignGpuChannels(allFilters: Filter[]): Filter[];
-/**
- * Assign a new gpu filter a channel based on first availability
- */
-export declare function assignGpuChannel(filter: Filter, filters: Filter[]): Filter;
-/**
- * Edit filter.gpu to ensure that only
- * X number of gpu filers can coexist.
- */
-export declare function resetFilterGpuMode(filters: Filter[]): Filter[];
-/**
- * Get filter properties for gpu filtering
- */
-export declare function getGpuFilterProps(filters: Filter[], dataId: string, fields: Field[]): GpuFilter;
-/**
- * Return dataset field index from filter.fieldIdx
- * The index matches the same dataset index for filter.dataId
- */
-export declare function getDatasetFieldIndexForFilter(dataId: string, filter: Filter): number;
+import { Filter } from 'reducers/vis-state-updaters';
+import { Field, GpuFilter } from './table-utils/kepler-table';
+/**
+ * Set gpu mode based on current number of gpu filters exists
+ */
+export declare function setFilterGpuMode(filter: Filter, filters: Filter[]): Filter;
+/**
+ * Scan though all filters and assign gpu chanel to gpu filter
+ */
+export declare function assignGpuChannels(allFilters: Filter[]): Filter[];
+/**
+ * Assign a new gpu filter a channel based on first availability
+ */
+export declare function assignGpuChannel(filter: Filter, filters: Filter[]): Filter;
+/**
+ * Edit filter.gpu to ensure that only
+ * X number of gpu filers can coexist.
+ */
+export declare function resetFilterGpuMode(filters: Filter[]): Filter[];
+/**
+ * Get filter properties for gpu filtering
+ */
+export declare function getGpuFilterProps(filters: Filter[], dataId: string, fields: Field[]): GpuFilter;
+/**
+ * Return dataset field index from filter.fieldIdx
+ * The index matches the same dataset index for filter.dataId
+ */
+export declare function getDatasetFieldIndexForFilter(dataId: string, filter: Filter): number;

package/dist/utils/gpu-filter-utils.js

@@ -0,0 +1,241 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assignGpuChannel = assignGpuChannel;
+exports.assignGpuChannels = assignGpuChannels;
+exports.getDatasetFieldIndexForFilter = getDatasetFieldIndexForFilter;
+exports.getGpuFilterProps = getGpuFilterProps;
+exports.resetFilterGpuMode = resetFilterGpuMode;
+exports.setFilterGpuMode = setFilterGpuMode;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _utils = require("./utils");
+var _defaultSettings = require("../constants/default-settings");
+var _dataUtils = require("./data-utils");
+var _moment = _interopRequireDefault(require("moment"));
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } // 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.
+/**
+ * Set gpu mode based on current number of gpu filters exists
+ */
+function setFilterGpuMode(filter, filters) {
+  // filter can be applied to multiple datasets, hence gpu filter mode should also be
+  // an array, however, to keep us sane, for now, we only check if there is available channel for every dataId,
+  // if all of them has, we set gpu mode to true
+  // TODO: refactor filter so we don't keep an array of everything
+
+  filter.dataId.forEach(function (dataId, datasetIdx) {
+    var gpuFilters = filters.filter(function (f) {
+      return f.dataId.includes(dataId) && f.gpu;
+    });
+    if (filter.gpu && gpuFilters.length === _defaultSettings.MAX_GPU_FILTERS) {
+      return (0, _utils.set)(['gpu'], false, filter);
+    }
+  });
+  return filter;
+}
+
+/**
+ * Scan though all filters and assign gpu chanel to gpu filter
+ */
+function assignGpuChannels(allFilters) {
+  return allFilters.reduce(function (accu, f, index) {
+    var filters = accu;
+
+    // if gpu is true assign and validate gpu Channel
+    if (f.gpu) {
+      f = assignGpuChannel(f, accu);
+      filters = (0, _utils.set)([index], f, accu);
+    }
+    return filters;
+  }, allFilters);
+}
+/**
+ * Assign a new gpu filter a channel based on first availability
+ */
+function assignGpuChannel(filter, filters) {
+  // find first available channel
+  if (!filter.gpu) {
+    return filter;
+  }
+  var gpuChannel = filter.gpuChannel || [];
+  filter.dataId.forEach(function (dataId, datasetIdx) {
+    var findGpuChannel = function findGpuChannel(channel) {
+      return function (f) {
+        var dataIdx = (0, _utils.toArray)(f.dataId).indexOf(dataId);
+        return f.id !== filter.id && dataIdx > -1 && f.gpu && (0, _utils.toArray)(f.gpuChannel)[dataIdx] === channel;
+      };
+    };
+    if (Number.isFinite(gpuChannel[datasetIdx]) && !filters.find(findGpuChannel(gpuChannel[datasetIdx]))) {
+      // if value is already assigned and valid
+      return;
+    }
+    var i = 0;
+    while (i < _defaultSettings.MAX_GPU_FILTERS) {
+      if (!filters.find(findGpuChannel(i))) {
+        gpuChannel[datasetIdx] = i;
+        return;
+      }
+      i++;
+    }
+  });
+
+  // if cannot find channel for all dataid, set gpu back to false
+  // TODO: refactor filter to handle same filter different gpu mode
+  if (!gpuChannel.length || !gpuChannel.every(Number.isFinite)) {
+    return _objectSpread(_objectSpread({}, filter), {}, {
+      gpu: false
+    });
+  }
+  return _objectSpread(_objectSpread({}, filter), {}, {
+    gpuChannel: gpuChannel
+  });
+}
+/**
+ * Edit filter.gpu to ensure that only
+ * X number of gpu filers can coexist.
+ */
+function resetFilterGpuMode(filters) {
+  var gpuPerDataset = {};
+  return filters.map(function (f, i) {
+    if (f.gpu) {
+      var gpu = true;
+      (0, _utils.toArray)(f.dataId).forEach(function (dataId) {
+        var count = gpuPerDataset[dataId];
+        if (count === _defaultSettings.MAX_GPU_FILTERS) {
+          gpu = false;
+        } else {
+          gpuPerDataset[dataId] = count ? count + 1 : 1;
+        }
+      });
+      if (!gpu) {
+        return (0, _utils.set)(['gpu'], false, f);
+      }
+    }
+    return f;
+  });
+}
+
+/**
+ * Initial filter uniform
+ */
+function getEmptyFilterRange() {
+  return new Array(_defaultSettings.MAX_GPU_FILTERS).fill(0).map(function (d) {
+    return [0, 0];
+  });
+}
+
+/**
+ * Returns index of the data element.
+ * @param {any} d Data element with row index info.
+ * @returns number
+ */
+var defaultGetIndex = function defaultGetIndex(d) {
+  return d.index;
+};
+
+/**
+ * Returns value at the specified row from the data container.
+ * @param dc Data container.
+ * @param d Data element with row index info.
+ * @param fieldIndex Column index in the data container.
+ * @returns
+ */
+var defaultGetData = function defaultGetData(dc, d, fieldIndex) {
+  return dc.valueAt(d.index, fieldIndex);
+};
+
+/**
+ * @param channels
+ * @param dataId
+ * @param fields
+ * @return {Function} getFilterValue
+ */
+var getFilterValueAccessor = function getFilterValueAccessor(channels, dataId, fields) {
+  return function (dc) {
+    return function () {
+      var getIndex = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultGetIndex;
+      var getData = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultGetData;
+      return function (d) {
+        return (
+          // for empty channel, value is 0 and min max would be [0, 0]
+          channels.map(function (filter) {
+            var _filter$domain;
+            if (!filter) {
+              return 0;
+            }
+            var fieldIndex = getDatasetFieldIndexForFilter(dataId, filter);
+            var field = fields[fieldIndex];
+            var value = filter.type === _defaultSettings.FILTER_TYPES.timeRange ? field.filterProps && Array.isArray(field.filterProps.mappedValue) ? field.filterProps.mappedValue[getIndex(d)] : _moment["default"].utc(getData(dc, d, fieldIndex)).valueOf() : getData(dc, d, fieldIndex);
+            return (0, _dataUtils.notNullorUndefined)(value) ? value - ((_filter$domain = filter.domain) === null || _filter$domain === void 0 ? void 0 : _filter$domain[0]) : Number.MIN_SAFE_INTEGER;
+          })
+        );
+      };
+    };
+  };
+};
+
+/**
+ * Get filter properties for gpu filtering
+ */
+function getGpuFilterProps(filters, dataId, fields) {
+  var filterRange = getEmptyFilterRange();
+  var triggers = {};
+
+  // array of filter for each channel, undefined, if no filter is assigned to that channel
+  var channels = [];
+  var _loop = function _loop(i) {
+    var _filter$domain2, _filter$domain3;
+    var filter = filters.find(function (f) {
+      return f.gpu && f.dataId.includes(dataId) && f.gpuChannel && f.gpuChannel[f.dataId.indexOf(dataId)] === i;
+    });
+    filterRange[i][0] = filter ? filter.value[0] - ((_filter$domain2 = filter.domain) === null || _filter$domain2 === void 0 ? void 0 : _filter$domain2[0]) : 0;
+    filterRange[i][1] = filter ? filter.value[1] - ((_filter$domain3 = filter.domain) === null || _filter$domain3 === void 0 ? void 0 : _filter$domain3[0]) : 0;
+    triggers["gpuFilter_".concat(i)] = filter ? filter.name[filter.dataId.indexOf(dataId)] : null;
+    channels.push(filter);
+  };
+  for (var i = 0; i < _defaultSettings.MAX_GPU_FILTERS; i++) {
+    _loop(i);
+  }
+  var filterValueAccessor = getFilterValueAccessor(channels, dataId, fields);
+  return {
+    filterRange: filterRange,
+    filterValueUpdateTriggers: triggers,
+    // @ts-expect-error
+    filterValueAccessor: filterValueAccessor
+  };
+}
+
+/**
+ * Return dataset field index from filter.fieldIdx
+ * The index matches the same dataset index for filter.dataId
+ */
+function getDatasetFieldIndexForFilter(dataId, filter) {
+  var datasetIndex = (0, _utils.toArray)(filter.dataId).indexOf(dataId);
+  if (datasetIndex < 0) {
+    return -1;
+  }
+  var fieldIndex = filter.fieldIdx[datasetIndex];
+  return (0, _dataUtils.notNullorUndefined)(fieldIndex) ? fieldIndex : -1;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_utils","require","_defaultSettings","_dataUtils","_moment","_interopRequireDefault","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","setFilterGpuMode","filters","dataId","datasetIdx","gpuFilters","f","includes","gpu","MAX_GPU_FILTERS","set","assignGpuChannels","allFilters","reduce","accu","index","assignGpuChannel","gpuChannel","findGpuChannel","channel","dataIdx","toArray","indexOf","id","Number","isFinite","find","i","every","resetFilterGpuMode","gpuPerDataset","map","count","getEmptyFilterRange","Array","fill","d","defaultGetIndex","defaultGetData","dc","fieldIndex","valueAt","getFilterValueAccessor","channels","fields","getIndex","undefined","getData","_filter$domain","getDatasetFieldIndexForFilter","field","value","type","FILTER_TYPES","timeRange","filterProps","isArray","mappedValue","moment","utc","valueOf","notNullorUndefined","domain","MIN_SAFE_INTEGER","getGpuFilterProps","filterRange","triggers","_loop","_filter$domain2","_filter$domain3","concat","name","filterValueAccessor","filterValueUpdateTriggers","datasetIndex","fieldIdx"],"sources":["../../src/utils/gpu-filter-utils.ts"],"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 {set, toArray} from './utils';\nimport {MAX_GPU_FILTERS, FILTER_TYPES} from 'constants/default-settings';\nimport {notNullorUndefined} from './data-utils';\nimport moment from 'moment';\nimport {Filter} from 'reducers/vis-state-updaters';\nimport {DataContainerInterface} from './table-utils/data-container-interface';\nimport {Field, GpuFilter} from './table-utils/kepler-table';\n\n/**\n * Set gpu mode based on current number of gpu filters exists\n */\nexport function setFilterGpuMode(filter: Filter, filters: Filter[]) {\n  // filter can be applied to multiple datasets, hence gpu filter mode should also be\n  // an array, however, to keep us sane, for now, we only check if there is available channel for every dataId,\n  // if all of them has, we set gpu mode to true\n  // TODO: refactor filter so we don't keep an array of everything\n\n  filter.dataId.forEach((dataId, datasetIdx) => {\n    const gpuFilters = filters.filter(f => f.dataId.includes(dataId) && f.gpu);\n\n    if (filter.gpu && gpuFilters.length === MAX_GPU_FILTERS) {\n      return set(['gpu'], false, filter);\n    }\n  });\n\n  return filter;\n}\n\n/**\n * Scan though all filters and assign gpu chanel to gpu filter\n */\nexport function assignGpuChannels(allFilters: Filter[]) {\n  return allFilters.reduce((accu, f, index) => {\n    let filters = accu;\n\n    // if gpu is true assign and validate gpu Channel\n    if (f.gpu) {\n      f = assignGpuChannel(f, accu);\n      filters = set([index], f, accu);\n    }\n\n    return filters;\n  }, allFilters);\n}\n/**\n * Assign a new gpu filter a channel based on first availability\n */\nexport function assignGpuChannel(filter: Filter, filters: Filter[]) {\n  // find first available channel\n  if (!filter.gpu) {\n    return filter;\n  }\n\n  const gpuChannel = filter.gpuChannel || [];\n\n  filter.dataId.forEach((dataId, datasetIdx) => {\n    const findGpuChannel = channel => f => {\n      const dataIdx = toArray(f.dataId).indexOf(dataId);\n      return (\n        f.id !== filter.id && dataIdx > -1 && f.gpu && toArray(f.gpuChannel)[dataIdx] === channel\n      );\n    };\n\n    if (\n      Number.isFinite(gpuChannel[datasetIdx]) &&\n      !filters.find(findGpuChannel(gpuChannel[datasetIdx]))\n    ) {\n      // if value is already assigned and valid\n      return;\n    }\n\n    let i = 0;\n\n    while (i < MAX_GPU_FILTERS) {\n      if (!filters.find(findGpuChannel(i))) {\n        gpuChannel[datasetIdx] = i;\n        return;\n      }\n      i++;\n    }\n  });\n\n  // if cannot find channel for all dataid, set gpu back to false\n  // TODO: refactor filter to handle same filter different gpu mode\n  if (!gpuChannel.length || !gpuChannel.every(Number.isFinite)) {\n    return {\n      ...filter,\n      gpu: false\n    };\n  }\n\n  return {\n    ...filter,\n    gpuChannel\n  };\n}\n/**\n * Edit filter.gpu to ensure that only\n * X number of gpu filers can coexist.\n */\nexport function resetFilterGpuMode(filters: Filter[]): Filter[] {\n  const gpuPerDataset = {};\n\n  return filters.map((f, i) => {\n    if (f.gpu) {\n      let gpu = true;\n      toArray(f.dataId).forEach(dataId => {\n        const count = gpuPerDataset[dataId];\n\n        if (count === MAX_GPU_FILTERS) {\n          gpu = false;\n        } else {\n          gpuPerDataset[dataId] = count ? count + 1 : 1;\n        }\n      });\n\n      if (!gpu) {\n        return set(['gpu'], false, f);\n      }\n    }\n\n    return f;\n  });\n}\n\n/**\n * Initial filter uniform\n */\nfunction getEmptyFilterRange() {\n  return new Array(MAX_GPU_FILTERS).fill(0).map(d => [0, 0]);\n}\n\n/**\n * Returns index of the data element.\n * @param {any} d Data element with row index info.\n * @returns number\n */\nconst defaultGetIndex = d => d.index;\n\n/**\n * Returns value at the specified row from the data container.\n * @param dc Data container.\n * @param d Data element with row index info.\n * @param fieldIndex Column index in the data container.\n * @returns\n */\nconst defaultGetData = (dc: DataContainerInterface, d: any, fieldIndex: number) => {\n  return dc.valueAt(d.index, fieldIndex);\n};\n\n/**\n * @param channels\n * @param dataId\n * @param fields\n * @return {Function} getFilterValue\n */\nconst getFilterValueAccessor = (\n  channels: (Filter | undefined)[],\n  dataId: string,\n  fields: any[]\n) => (dc: DataContainerInterface) => (getIndex = defaultGetIndex, getData = defaultGetData) => d =>\n  // for empty channel, value is 0 and min max would be [0, 0]\n  channels.map(filter => {\n    if (!filter) {\n      return 0;\n    }\n    const fieldIndex = getDatasetFieldIndexForFilter(dataId, filter);\n    const field = fields[fieldIndex];\n\n    const value =\n      filter.type === FILTER_TYPES.timeRange\n        ? field.filterProps && Array.isArray(field.filterProps.mappedValue)\n          ? field.filterProps.mappedValue[getIndex(d)]\n          : moment.utc(getData(dc, d, fieldIndex)).valueOf()\n        : getData(dc, d, fieldIndex);\n\n    return notNullorUndefined(value) ? value - filter.domain?.[0] : Number.MIN_SAFE_INTEGER;\n  });\n\n/**\n * Get filter properties for gpu filtering\n */\nexport function getGpuFilterProps(filters: Filter[], dataId: string, fields: Field[]): GpuFilter {\n  const filterRange = getEmptyFilterRange();\n  const triggers = {};\n\n  // array of filter for each channel, undefined, if no filter is assigned to that channel\n  const channels: (Filter | undefined)[] = [];\n\n  for (let i = 0; i < MAX_GPU_FILTERS; i++) {\n    const filter = filters.find(\n      f =>\n        f.gpu &&\n        f.dataId.includes(dataId) &&\n        f.gpuChannel &&\n        f.gpuChannel[f.dataId.indexOf(dataId)] === i\n    );\n\n    filterRange[i][0] = filter ? filter.value[0] - filter.domain?.[0] : 0;\n    filterRange[i][1] = filter ? filter.value[1] - filter.domain?.[0] : 0;\n\n    triggers[`gpuFilter_${i}`] = filter ? filter.name[filter.dataId.indexOf(dataId)] : null;\n    channels.push(filter);\n  }\n\n  const filterValueAccessor = getFilterValueAccessor(channels, dataId, fields);\n\n  return {\n    filterRange,\n    filterValueUpdateTriggers: triggers,\n    // @ts-expect-error\n    filterValueAccessor\n  };\n}\n\n/**\n * Return dataset field index from filter.fieldIdx\n * The index matches the same dataset index for filter.dataId\n */\nexport function getDatasetFieldIndexForFilter(dataId: string, filter: Filter): number {\n  const datasetIndex = toArray(filter.dataId).indexOf(dataId);\n  if (datasetIndex < 0) {\n    return -1;\n  }\n\n  const fieldIndex = filter.fieldIdx[datasetIndex];\n\n  return notNullorUndefined(fieldIndex) ? fieldIndex : -1;\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/utils/index.d.ts

@@ -1,22 +1,22 @@
-export { maybeToDate, roundValToStep, timeToUnixMilli, defaultFormatter, FIELD_DISPLAY_FORMAT } from './data-utils';
-export { createNewDataEntry, datasetColorMaker, findDefaultColorField } from './dataset-utils';
-export { hexToRgb, checkColorOrFallback } from './color-utils';
-export { errorNotification } from './notifications-utils';
-export { dataURItoBlob, downloadFile } from './export-utils';
-export { calculateLayerData, prepareLayersToRender, prepareLayersForDeck, negateAccessor } from './layer-utils';
-export { applyFilterFieldName, applyFiltersToDatasets, validateFilterWithData, validateFiltersUpdateDatasets, getIntervalBins, getNumericStepSize, formatNumberByStep } from 'utils/filter-utils';
-export { resetFilterGpuMode, assignGpuChannels } from 'utils/gpu-filter-utils';
-export { updateAllLayerDomainData } from '../reducers/vis-state-updaters';
-export { getHexFields } from '../layers/h3-hexagon-layer/h3-utils';
-export { containValidTime } from '../layers/trip-layer/trip-utils';
-export { default as KeplerTable, findPointFieldPairs, copyTableAndUpdate } from './table-utils/kepler-table';
-export { createDataContainer, createIndexedDataContainer } from './table-utils/data-container-utils';
-export * from './color-utils';
-export * from './data-scale-utils';
-export * from './data-utils';
-export * from './dataset-utils';
-export * from './gpu-filter-utils';
-export * from './interaction-utils';
-export * from './layer-utils';
-export * from './observe-dimensions';
-export { generateHashId } from './utils';
+export { maybeToDate, roundValToStep, timeToUnixMilli, defaultFormatter, FIELD_DISPLAY_FORMAT } from './data-utils';
+export { createNewDataEntry, datasetColorMaker, findDefaultColorField } from './dataset-utils';
+export { hexToRgb, checkColorOrFallback } from './color-utils';
+export { errorNotification } from './notifications-utils';
+export { dataURItoBlob, downloadFile } from './export-utils';
+export { calculateLayerData, prepareLayersToRender, prepareLayersForDeck, negateAccessor } from './layer-utils';
+export { applyFilterFieldName, applyFiltersToDatasets, validateFilterWithData, validateFiltersUpdateDatasets, getIntervalBins, getNumericStepSize, formatNumberByStep } from 'utils/filter-utils';
+export { resetFilterGpuMode, assignGpuChannels } from 'utils/gpu-filter-utils';
+export { updateAllLayerDomainData } from '../reducers/vis-state-updaters';
+export { getHexFields } from '../layers/h3-hexagon-layer/h3-utils';
+export { containValidTime } from '../layers/trip-layer/trip-utils';
+export { default as KeplerTable, findPointFieldPairs, copyTableAndUpdate } from './table-utils/kepler-table';
+export { createDataContainer, createIndexedDataContainer } from './table-utils/data-container-utils';
+export * from './color-utils';
+export * from './data-scale-utils';
+export * from './data-utils';
+export * from './dataset-utils';
+export * from './gpu-filter-utils';
+export * from './interaction-utils';
+export * from './layer-utils';
+export * from './observe-dimensions';
+export { generateHashId } from './utils';