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

package/src/utils/gl-utils.js

@@ -0,0 +1,42 @@
+// 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.
+
+import {setParameters} from '@luma.gl/core';
+import {LAYER_BLENDINGS} from 'constants/default-settings';
+import GL from '@luma.gl/constants';
+
+const getGlConst = d => GL[d];
+
+export function setLayerBlending(gl, layerBlending) {
+  const blending = LAYER_BLENDINGS[layerBlending];
+  const {blendFunc, blendEquation} = blending;
+
+  setParameters(gl, {
+    [GL.BLEND]: true,
+    ...(blendFunc
+      ? {
+          blendFunc: blendFunc.map(getGlConst),
+          blendEquation: Array.isArray(blendEquation)
+            ? blendEquation.map(getGlConst)
+            : getGlConst(blendEquation)
+        }
+      : {})
+  });
+}

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

@@ -0,0 +1,28 @@
+// Copyright (c) 2020 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.
+
+import {Filter, Field, GpuFilter} from 'reducers/vis-state-updaters';
+
+export function setFilterGpuMode(filter: Filter, filters: Filter[]): Filter;
+export function assignGpuChannel(filter: Filter, filters: Filter[]): Filter;
+export function assignGpuChannels(allFilters: Filter[]): Filter[];
+export function resetFilterGpuMode(filters: Filter[]): Filter[];
+export function getGpuFilterProps(filters: Filter[], dataId: string, fields: Field[]): GpuFilter;
+export function getDatasetFieldIndexForFilter(dataId: string, filter: Filter): number;

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

@@ -0,0 +1,253 @@
+// 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.
+
+import {set, toArray} from './utils';
+import {MAX_GPU_FILTERS, FILTER_TYPES} from 'constants/default-settings';
+import {notNullorUndefined} from './data-utils';
+import moment from 'moment';
+
+/**
+ * Set gpu mode based on current number of gpu filters exists
+ * @type {typeof import('./gpu-filter-utils').setFilterGpuMode}
+ */
+export 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((dataId, datasetIdx) => {
+    const gpuFilters = filters.filter(f => f.dataId.includes(dataId) && f.gpu);
+
+    if (filter.gpu && gpuFilters.length === MAX_GPU_FILTERS) {
+      return set(['gpu'], false, filter);
+    }
+  });
+
+  return filter;
+}
+
+/**
+ * Scan though all filters and assign gpu chanel to gpu filter
+ * @type {typeof import('./gpu-filter-utils').assignGpuChannels}
+ */
+export function assignGpuChannels(allFilters) {
+  return allFilters.reduce((accu, f, index) => {
+    let filters = accu;
+
+    // if gpu is true assign and validate gpu Channel
+    if (f.gpu) {
+      f = assignGpuChannel(f, accu);
+      filters = set([index], f, accu);
+    }
+
+    return filters;
+  }, allFilters);
+}
+/**
+ * Assign a new gpu filter a channel based on first availability
+ * @type {typeof import('./gpu-filter-utils').assignGpuChannel}
+ */
+export function assignGpuChannel(filter, filters) {
+  // find first available channel
+  if (!filter.gpu) {
+    return filter;
+  }
+
+  const gpuChannel = filter.gpuChannel || [];
+
+  filter.dataId.forEach((dataId, datasetIdx) => {
+    const findGpuChannel = channel => f => {
+      const dataIdx = toArray(f.dataId).indexOf(dataId);
+      return (
+        f.id !== filter.id && dataIdx > -1 && f.gpu && toArray(f.gpuChannel)[dataIdx] === channel
+      );
+    };
+
+    if (
+      Number.isFinite(gpuChannel[datasetIdx]) &&
+      !filters.find(findGpuChannel(gpuChannel[datasetIdx]))
+    ) {
+      // if value is already assigned and valid
+      return;
+    }
+
+    let i = 0;
+
+    while (i < 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 {
+      ...filter,
+      gpu: false
+    };
+  }
+
+  return {
+    ...filter,
+    gpuChannel
+  };
+}
+/**
+ * Edit filter.gpu to ensure that only
+ * X number of gpu filers can coexist.
+ * @type {typeof import('./gpu-filter-utils').resetFilterGpuMode}
+ */
+export function resetFilterGpuMode(filters) {
+  const gpuPerDataset = {};
+
+  return filters.map((f, i) => {
+    if (f.gpu) {
+      let gpu = true;
+      toArray(f.dataId).forEach(dataId => {
+        const count = gpuPerDataset[dataId];
+
+        if (count === MAX_GPU_FILTERS) {
+          gpu = false;
+        } else {
+          gpuPerDataset[dataId] = count ? count + 1 : 1;
+        }
+      });
+
+      if (!gpu) {
+        return set(['gpu'], false, f);
+      }
+    }
+
+    return f;
+  });
+}
+
+/**
+ * Initial filter uniform
+ * @returns {Array<Array<Number>>}
+ */
+function getEmptyFilterRange() {
+  return new Array(MAX_GPU_FILTERS).fill(0).map(d => [0, 0]);
+}
+
+/**
+ * Returns index of the data element.
+ * @param {any} d Data element with row index info.
+ * @returns number
+ */
+const defaultGetIndex = d => d.index;
+
+/**
+ * Returns value at the specified row from the data container.
+ * @param {import('./table-utils/data-container-interface').DataContainerInterface} dc Data container.
+ * @param {any} d Data element with row index info.
+ * @param {number} fieldIndex Column index in the data container.
+ * @returns
+ */
+const defaultGetData = (dc, d, fieldIndex) => {
+  return dc.valueAt(d.index, fieldIndex);
+};
+
+/**
+ * @param {Array<Object>} channels
+ * @param {string} dataId
+ * @param {Array<Object>} fields
+ * @return {Function} getFilterValue
+ */
+const getFilterValueAccessor = (channels, dataId, fields) => dc => (
+  getIndex = defaultGetIndex,
+  getData = defaultGetData
+) => d =>
+  // for empty channel, value is 0 and min max would be [0, 0]
+  channels.map(filter => {
+    if (!filter) {
+      return 0;
+    }
+    const fieldIndex = getDatasetFieldIndexForFilter(dataId, filter);
+    const field = fields[fieldIndex];
+
+    const value =
+      filter.type === FILTER_TYPES.timeRange
+        ? field.filterProps && Array.isArray(field.filterProps.mappedValue)
+          ? field.filterProps.mappedValue[getIndex(d)]
+          : moment.utc(getData(dc, d, fieldIndex)).valueOf()
+        : getData(dc, d, fieldIndex);
+
+    return notNullorUndefined(value) ? value - filter.domain[0] : Number.MIN_SAFE_INTEGER;
+  });
+
+/**
+ * Get filter properties for gpu filtering
+ * @type {typeof import('./gpu-filter-utils').getGpuFilterProps}
+ */
+export function getGpuFilterProps(filters, dataId, fields) {
+  const filterRange = getEmptyFilterRange();
+  const triggers = {};
+
+  // array of filter for each channel, undefined, if no filter is assigned to that channel
+  const channels = [];
+
+  for (let i = 0; i < MAX_GPU_FILTERS; i++) {
+    const filter = filters.find(
+      f =>
+        f.gpu &&
+        f.dataId.includes(dataId) &&
+        f.gpuChannel &&
+        f.gpuChannel[f.dataId.indexOf(dataId)] === i
+    );
+
+    // @ts-ignore
+    filterRange[i][0] = filter ? filter.value[0] - filter.domain[0] : 0;
+    // @ts-ignore
+    filterRange[i][1] = filter ? filter.value[1] - filter.domain[0] : 0;
+
+    triggers[`gpuFilter_${i}`] = filter ? filter.name[filter.dataId.indexOf(dataId)] : null;
+    channels.push(filter);
+  }
+
+  const filterValueAccessor = getFilterValueAccessor(channels, dataId, fields);
+
+  return {
+    filterRange,
+    filterValueUpdateTriggers: triggers,
+    filterValueAccessor
+  };
+}
+
+/**
+ * Return dataset field index from filter.fieldIdx
+ * The index matches the same dataset index for filter.dataId
+ * @type {typeof import('./gpu-filter-utils').getDatasetFieldIndexForFilter}
+ */
+export function getDatasetFieldIndexForFilter(dataId, filter) {
+  const datasetIndex = toArray(filter.dataId).indexOf(dataId);
+  if (datasetIndex < 0) {
+    return -1;
+  }
+
+  const fieldIndex = filter.fieldIdx[datasetIndex];
+
+  return notNullorUndefined(fieldIndex) ? fieldIndex : -1;
+}

package/src/utils/index.d.ts

@@ -0,0 +1,5 @@
+
+export {maybeToDate, roundValToStep} from './data-utils';
+export {updateAllLayerDomainData} from '../reducers/vis-state-updaters';
+// export {getHexFields} from '../layers/h3-hexagon-layer/h3-utils';
+export {default as KeplerTable, Field, findPointFieldPairs} from './table-utils/kepler-table';

package/src/utils/index.js

@@ -0,0 +1,55 @@
+// 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.
+
+// UTILS
+export {
+  maybeToDate,
+  roundValToStep,
+  timeToUnixMilli,
+  defaultFormatter,
+  FIELD_DISPLAY_FORMAT
+} from './data-utils';
+export {createNewDataEntry, datasetColorMaker, findDefaultColorField} from './dataset-utils';
+export {hexToRgb} 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';
+
+// REDUCER 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} from './table-utils/kepler-table';
+export {createDataContainer, createIndexedDataContainer} from './table-utils/data-container-utils';

package/src/utils/interaction-utils.d.ts

@@ -0,0 +1,36 @@
+import {InteractionConfig, Field, TooltipField, CompareType} from '../reducers/vis-state-updaters';
+import {DataRow} from './table-utils/data-row';
+
+/**
+ * Minus sign used in tooltip formatting.
+ */
+export const TOOLTIP_MINUS_SIGN: string;
+
+export const BRUSH_CONFIG: {
+  range: [number, number];
+};
+
+export function getDefaultInteraction(): InteractionConfig;
+
+export function findFieldsToShow(p: {
+  fields: Field[];
+  id: string;
+}): {
+  [key: string]: string[];
+};
+
+export function getTooltipDisplayDeltaValue(args: {
+  item: TooltipField;
+  field: Field;
+  data: DataRow;
+  fieldIdx: number;
+  primaryData: DataRow;
+  compareType: CompareType;
+}): string | null;
+
+export function getTooltipDisplayValue(args: {
+  item: TooltipField;
+  field: Field;
+  data: DataRow;
+  fieldIdx: number;
+}): string;

package/src/utils/interaction-utils.js

@@ -0,0 +1,185 @@
+// 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.
+
+import {
+  DEFAULT_TOOLTIP_FIELDS,
+  MAX_DEFAULT_TOOLTIPS,
+  ALL_FIELD_TYPES,
+  TRIP_POINT_FIELDS
+} from 'constants/default-settings';
+import {
+  parseFieldValue,
+  getFormatter,
+  isNumber,
+  defaultFormatter,
+  notNullorUndefined
+} from 'utils/data-utils';
+import {Messages, Crosshairs, CursorClick, Pin} from 'components/common/icons/index';
+import {TOOLTIP_FORMATS, TOOLTIP_KEY, COMPARE_TYPES} from 'constants/tooltip';
+
+// \u2212 is the minus sign that d3-format uses for decimal number formatting
+export const TOOLTIP_MINUS_SIGN = '\u2212';
+
+/**
+ * @type {typeof import('./interaction-utils').getDefaultInteraction}
+ */
+export function getDefaultInteraction() {
+  return {
+    tooltip: {
+      id: 'tooltip',
+      label: 'interactions.tooltip',
+      enabled: true,
+      iconComponent: Messages,
+      config: {
+        fieldsToShow: {},
+        compareMode: false,
+        compareType: COMPARE_TYPES.ABSOLUTE
+      }
+    },
+    geocoder: {
+      id: 'geocoder',
+      label: 'interactions.geocoder',
+      enabled: false,
+      iconComponent: Pin,
+      position: null
+    },
+    brush: {
+      id: 'brush',
+      label: 'interactions.brush',
+      enabled: false,
+      iconComponent: Crosshairs,
+      config: {
+        // size is in km
+        size: 0.5
+      }
+    },
+    coordinate: {
+      id: 'coordinate',
+      label: 'interactions.coordinate',
+      enabled: false,
+      iconComponent: CursorClick,
+      position: null
+    }
+  };
+}
+
+export const BRUSH_CONFIG = {
+  range: [0, 50]
+};
+
+/**
+ * @type {typeof import('./interaction-utils').findFieldsToShow}
+ */
+export function findFieldsToShow({fields, id}) {
+  // first find default tooltip fields for trips
+  const fieldsToShow = DEFAULT_TOOLTIP_FIELDS.reduce((prev, curr) => {
+    if (fields.find(({name}) => curr.name === name)) {
+      prev.push(curr);
+    }
+    return prev;
+  }, []);
+
+  return {
+    [id]: fieldsToShow.length ? fieldsToShow : autoFindTooltipFields(fields)
+  };
+}
+
+function autoFindTooltipFields(fields) {
+  const ptFields = _mergeFieldPairs(TRIP_POINT_FIELDS);
+  // filter out the default fields that contains lat and lng and any geometry
+  const fieldsToShow = fields.filter(
+    ({name, type}) =>
+      name
+        .replace(/[_,.]+/g, ' ')
+        .trim()
+        .split(' ')
+        .every(seg => !ptFields.includes(seg)) &&
+      type !== ALL_FIELD_TYPES.geojson &&
+      type !== 'object'
+  );
+
+  return fieldsToShow.slice(0, MAX_DEFAULT_TOOLTIPS).map(({name}) => {
+    return {
+      name,
+      format: null
+    };
+  });
+}
+
+function _mergeFieldPairs(pairs) {
+  return pairs.reduce((prev, pair) => [...prev, ...pair], []);
+}
+
+/**
+ * @type {typeof import('./interaction-utils').getTooltipDisplayDeltaValue}
+ */
+export function getTooltipDisplayDeltaValue({
+  primaryData,
+  field,
+  compareType,
+  data,
+  fieldIdx,
+  item
+}) {
+  let displayDeltaValue = null;
+
+  if (
+    primaryData &&
+    // comparison mode only works for numeric field
+    (field.type === ALL_FIELD_TYPES.integer || field.type === ALL_FIELD_TYPES.real)
+  ) {
+    const baseDp = primaryData.valueAt(fieldIdx);
+    const dp = data.valueAt(fieldIdx);
+    if (isNumber(baseDp) && isNumber(dp)) {
+      const deltaValue = compareType === COMPARE_TYPES.RELATIVE ? dp / baseDp - 1 : dp - baseDp;
+      const deltaFormat =
+        compareType === COMPARE_TYPES.RELATIVE
+          ? TOOLTIP_FORMATS.DECIMAL_PERCENT_FULL_2[TOOLTIP_KEY]
+          : item.format || TOOLTIP_FORMATS.DECIMAL_DECIMAL_FIXED_3[TOOLTIP_KEY];
+
+      displayDeltaValue = getFormatter(deltaFormat)(deltaValue);
+
+      // safely cast string
+      displayDeltaValue = defaultFormatter(displayDeltaValue);
+      const deltaFirstChar = displayDeltaValue.charAt(0);
+      if (deltaFirstChar !== '+' && deltaFirstChar !== TOOLTIP_MINUS_SIGN) {
+        displayDeltaValue = `+${displayDeltaValue}`;
+      }
+    } else {
+      displayDeltaValue = TOOLTIP_MINUS_SIGN;
+    }
+  }
+
+  return displayDeltaValue;
+}
+
+/**
+ * @type {typeof import('./interaction-utils').getTooltipDisplayValue}
+ */
+export function getTooltipDisplayValue({item, field, data, fieldIdx}) {
+  const dataValue = data.valueAt(fieldIdx);
+  if (!notNullorUndefined(dataValue)) {
+    return '';
+  }
+
+  return item.format
+    ? getFormatter(item.format, field)(dataValue)
+    : parseFieldValue(dataValue, field.type);
+}

package/src/utils/layer-utils.d.ts

@@ -0,0 +1,78 @@
+// Copyright (c) 2020 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.
+
+import {Layer, LayerClassesType} from 'layers';
+import {VisState, Dataset, TooltipField, CompareType, SplitMapLayers} from 'reducers/vis-state-updaters';
+
+export function calculateLayerData(
+  layer: Layer,
+  state: VisState,
+  oldLayerData?: any
+): {
+  layerData: any;
+  layer: Layer;
+};
+
+export type LayersToRender = {
+  [layerId: string]: boolean;
+};
+
+export type LayerHoverProp = {
+  data: any[];
+  fields: Field[];
+  fieldsToShow: TooltipField[];
+  layer: Layer;
+  primaryData?: any[];
+  compareType?: CompareType
+};
+
+export function findDefaultLayer(dataset: Dataset, layerClasses: LayerClassesType): Layer[];
+export function getLayerHoverProp(arg: {
+  interactionConfig: VisState['interactionConfig'];
+  hoverInfo: VisState['hoverInfo'];
+  layers: VisState['layers'];
+  layersToRender: LayersToRender;
+  datasets: VisState['datasets'];
+}): LayerHoverProp | null;
+
+export function renderDeckGlLayer(props: any, layerCallbacks: {[key]: any}, idx: number);
+
+export function prepareLayersToRender(
+  layers: Layer, 
+  layerData: VisState['layerData'], 
+  mapLayers?: SplitMapLayers): {
+  [key: string]: boolean;
+}
+
+export function prepareLayersForDeck(
+  layers: Layer, 
+  layerData: VisState['layerData'], 
+): {
+  [key: string]: boolean;
+}
+
+export function getMaskExtensionProps(
+  maskPolygon: Array<Array<number>>, 
+): {
+  maskId?: string,
+  extensions: Array<unknown>
+}
+
+export function negateAccessor<T extends ((d: any) => number) | number>(accessor: T): T;