Skip to content

Kepler.gl is a powerful open source geospatial analysis tool for large-scale data sets.

[Chore]: Technical: Translate filter-utils and gpu-filter-utils (#1744)

Maksim Suslov7ee74ebed1cd
diff --git a/src/reducers/types.ts b/src/reducers/types.ts
index 0621e00c3..046e831e4 100644
--- a/src/reducers/types.ts
+++ b/src/reducers/types.ts
@@ -8,3 +8,7 @@ export type ValueOf<T> = T[keyof T];
export type Merge<A, B> = {[K in keyof A]: K extends keyof B ? B[K] : A[K]} & B extends infer O
? {[K in keyof O]: O[K]}
: never;
+
+export type Entries<T> = {
+ [K in keyof T]: [K, T[K]];
+}[keyof T][];
diff --git a/src/utils/filter-utils.d.ts b/src/utils/filter-utils.d.ts
deleted file mode 100644
index be96a7c8d..000000000
--- a/src/utils/filter-utils.d.ts
+++ /dev/null
@@ -1,192 +0,0 @@
-import {
- Filter,
- FilterBase,
- PolygonFilter,
- KeplerTable,
- Datasets,
- FilterRecord,
- FieldDomain,
- TimeRangeFieldDomain,
- HistogramBin,
- Feature,
- FeatureValue,
- VisState,
- LineChart,
- TimeRangeFilter
-} from '../reducers/vis-state-updaters';
-import {Layer} from 'layers';
-import {Field} from 'reducers/types';
-import {ParsedConfig} from 'schemas';
-import {FilterDatasetOpt} from './table-utils/kepler-table';
-import {DataContainerInterface} from './table-utils/data-container-interface';
-import {DataRow} from './table-utils/data-row';
-
-export function applyFilterFieldName(
- filter: Filter,
- dataset: KeplerTable,
- fieldName: string,
- filterDatasetIndex?: number,
- option?: {mergeDomain: boolean}
-): {
- filter: Filter | null;
- dataset: KeplerTable;
-};
-
-export function getDefaultFilter(dataId: string | null | string[]): FilterBase;
-export function shouldApplyFilter(filter: Filter, datasetId: string): boolean;
-export function validatePolygonFilter(
- dataset: KeplerTable,
- filter: PolygonFilter,
- layers: Layer[]
-): {filter: PolygonFilter | null; dataset: KeplerTable};
-
-export function validateFilter(
- dataset: KeplerTable,
- filter: Filter
-): {filter: PolygonFilter | null; dataset: KeplerTable};
-
-export function adjustValueToFilterDomain(value: Filter['value'], Filter): any;
-
-export function filterDataset(
- dataset: KeplerTable,
- filters: Filter[],
- layers: Layer[],
- opt?: FilterDatasetOpt
-): KeplerTable;
-
-export function applyFiltersToDatasets(
- datasetIds: string[],
- datasets: Datasets,
- filters: Filter[],
- layers?: Layer[]
-): Datasets;
-export function getFilterRecord(
- dataId: string,
- filters: Filter[],
- option?: FilterDatasetOpt
-): FilterRecord;
-
-/**
- * @param param An object that represents a row record.
- * @param param.index Index of the row in data container.
- * @returns Returns true to keep the element, or false otherwise.
- */
-function filterFunction(
- data: {index: number}
-): boolean;
-
-export function isValidFilterValue(type: string | null, value: any): boolean;
-export function getFilterFunction(
- field: Field | null,
- dataId: string,
- filter: Filter,
- layers: Layer[],
- dataContainer: DataContainerInterface
-): typeof filterFunction;
-
-export type FilterResult = {
- filteredIndexForDomain?: number[];
- filteredIndex?: number[];
-};
-export function filterDataByFilterTypes(
- filters: {
- dynamicDomainFilters: Filter[] | null;
- cpuFilters: Filter[] | null;
- filterFuncs: {
- [key: string]: typeof filterFunction;
- };
- },
- dataContainer: DataContainerInterface
-): FilterResult;
-
-export type FilterChanged = {
- [key in keyof FilterRecord]: {
- [key: string]: 'added' | 'deleted' | 'name_changed' | 'value_changed' | 'dataId_changed';
- } | null;
-};
-export function diffFilters(
- filterRecord: FilterRecord,
- oldFilterRecord?: FilterRecord | {}
-): FilterChanged;
-
-export function dataValueAccessor(data: {index: number}): number | null;
-export function getTimestampFieldDomain(
- dataContainer: DataContainerInterface,
- valueAccessor: typeof dataValueAccessor
-): TimeRangeFieldDomain;
-
-export function getNumericFieldDomain(
- dataContainer: DataContainerInterface,
- valueAccessor: typeof dataValueAccessor
-): RangeFieldDomain;
-
-export function histogramConstruct(
- domain: [number, number],
- mappedValue: (Millisecond | null | number)[],
- bins: number
-): HistogramBin[];
-
-export function getHistogram(
- domain: [number, number],
- mappedValue: (Millisecond | null | number)[]
-): {histogram: HistogramBin[]; enlargedHistogram: HistogramBin[]};
-
-export function getNumericStepSize(diff: number): number;
-
-export function formatNumberByStep(val: number, step: number, bound: 'floor' | 'ceil'): number;
-
-export function mergeFilterDomainStep(filter: Filter, filterProps?: any): Filter | null;
-
-export function getFilterProps(
- field: Field,
- FieldDomain: FieldDomain
-): Partiel<Filter> & {fieldType: string};
-
-export function generatePolygonFilter(layers: Layer[], feature: Feature): PolygonFilter;
-
-export function filterDatasetCPU(state: VisState, dataId: string): VisState;
-
-export function validateFilterWithData(
- dataset: KeplerTable,
- filter: Filter,
- layers: Layer[]
-): {filter: Filter; dataset: KeplerTable};
-export function featureToFilterValue(
- feature: Feature,
- filterId: string,
- properties?: {}
-): FeatureValue;
-
-export function getDefaultFilterPlotType(filter: Filter): string | null;
-export function getFilterPlot(
- filter: Filter,
- dataset: KeplerTable
-): {lineChart: LineChart; yAxs: Field} | {};
-export function getFilterIdInFeature(f: FeatureValue): string;
-export function isInRange(v: any, domain: number[]): boolean;
-export function updateFilterDataId(dataId: string): FilterBase;
-export function validateFiltersUpdateDatasets(
- state: VisState,
- filtersToValidate: ParsedConfig['visState']['filters']
-): {
- validated: Filter[];
- failed: Filter[];
- updatedDatasets: Datasets;
-};
-export function isInPolygon(point: number[], polygon: object): boolean;
-export function getIntervalBins(filter: TimeRangeFilter);
-export function getTimeWidgetHintFormatter(domain: [number, number]): string;
-export function getTimeWidgetTitleFormatter(domain: [number, number]): string;
-
-export const FILTER_UPDATER_PROPS: {
- dataId: string;
- name: string;
- layerId: string;
-};
-export const LIMITED_FILTER_EFFECT_PROPS: {
- name: string;
-};
-export const PLOT_TYPES: {
- histogram: string;
- lineChart: string;
-};
diff --git a/src/utils/filter-utils.js b/src/utils/filter-utils.ts
similarity index 78%
rename from src/utils/filter-utils.js
rename to src/utils/filter-utils.ts
index 53c3365e2..447904a38 100644
--- a/src/utils/filter-utils.js
+++ b/src/utils/filter-utils.ts
@@ -34,9 +34,40 @@ import {LAYER_TYPES} from 'layers/types';
import {generateHashId, set, toArray} from './utils';
import {getCentroid, h3IsValid} from 'layers/h3-hexagon-layer/h3-utils';
-// TYPE
-/** @typedef {import('./table-utils/kepler-table').FilterRecord} FilterRecord */
-/** @typedef {import('./filter-utils').FilterResult} FilterResult */
+import {
+ Filter,
+ FilterBase,
+ PolygonFilter,
+ Datasets,
+ FieldDomain,
+ TimeRangeFieldDomain,
+ HistogramBin,
+ Feature,
+ FeatureValue,
+ VisState,
+ LineChart,
+ TimeRangeFilter,
+ RangeFieldDomain
+} from '../reducers/vis-state-updaters';
+import KeplerTable, {Field, FilterRecord, FilterDatasetOpt} from './table-utils/kepler-table';
+import {Layer} from 'layers';
+import {ParsedFilter} from 'schemas';
+import {DataContainerInterface} from './table-utils/data-container-interface';
+import {Millisecond} from 'cloud-providers';
+import {Entries} from 'reducers';
+
+export type FilterResult = {
+ filteredIndexForDomain?: number[];
+ filteredIndex?: number[];
+};
+
+export type FilterChanged = {
+ [key in keyof FilterRecord]: {
+ [key: string]: 'added' | 'deleted' | 'name_changed' | 'value_changed' | 'dataId_changed';
+ } | null;
+};
+
+export type dataValueAccessor = (data: {index: number}) => number | null;
export const TimestampStepMap = [
{max: 1, step: 0.05},
@@ -131,9 +162,8 @@ export const LAYER_FILTERS = [FILTER_TYPES.polygon];
/**
* Generates a filter with a dataset id as dataId
- * @type {typeof import('./filter-utils').getDefaultFilter}
*/
-export function getDefaultFilter(dataId) {
+export function getDefaultFilter(dataId: string | null | string[]): FilterBase {
return {
...DEFAULT_FILTER_STRUCTURE,
// store it as dataId and it could be one or many
@@ -147,9 +177,8 @@ export function getDefaultFilter(dataId) {
* @param filter to validate
* @param datasetId id to validate filter against
* @return true if a filter is valid, false otherwise
- * @type {typeof import('./filter-utils').shouldApplyFilter}
*/
-export function shouldApplyFilter(filter, datasetId) {
+export function shouldApplyFilter(filter: Filter, datasetId: string): boolean {
const dataIds = toArray(filter.dataId);
return dataIds.includes(datasetId) && filter.value !== null;
}
@@ -160,9 +189,12 @@ export function shouldApplyFilter(filter, datasetId) {
* @param filter
* @param layers
* @return - {filter, dataset}
- * @type {typeof import('./filter-utils').validatePolygonFilter}
*/
-export function validatePolygonFilter(dataset, filter, layers) {
+export function validatePolygonFilter(
+ dataset: KeplerTable,
+ filter: PolygonFilter,
+ layers: Layer[]
+): {filter: PolygonFilter | null; dataset: KeplerTable} {
const failed = {dataset, filter: null};
const {value, layerId, type, dataId} = filter;
@@ -204,9 +236,11 @@ const filterValidators = {
* @param dataset
* @param filter
* @return - {filter, dataset}
- * @type {typeof import('./filter-utils').validateFilter}
*/
-export function validateFilter(dataset, filter) {
+export function validateFilter(
+ dataset: KeplerTable,
+ filter: ParsedFilter
+): {filter: Filter | null; dataset: KeplerTable} {
// match filter.dataId
const failed = {dataset, filter: null};
const filterDataId = toArray(filter.dataId);
@@ -217,7 +251,9 @@ export function validateFilter(dataset, filter) {
return failed;
}
- const initializeFilter = {
+ // @ts-expect-error
+ const initializeFilter: Filter = {
+ // @ts-expect-error
...getDefaultFilter(filter.dataId),
...filter,
dataId: filterDataId,
@@ -260,11 +296,13 @@ export function validateFilter(dataset, filter) {
* @param filter - filter to be validate
* @param layers - layers
* @return validated filter
- * @type {typeof import('./filter-utils').validateFilterWithData}
*/
-export function validateFilterWithData(dataset, filter, layers) {
- // @ts-ignore
- return filterValidators.hasOwnProperty(filter.type)
+export function validateFilterWithData(
+ dataset: KeplerTable,
+ filter: ParsedFilter,
+ layers: Layer[]
+): {filter: Filter; dataset: KeplerTable} {
+ return filter.type && filterValidators.hasOwnProperty(filter.type)
? filterValidators[filter.type](dataset, filter, layers)
: validateFilter(dataset, filter);
}
@@ -302,9 +340,11 @@ function validateFilterYAxis(filter, dataset) {
* @param field
* @param fieldDomain
* @returns default filter
- * @type {typeof import('./filter-utils').getFilterProps}
*/
-export function getFilterProps(field, fieldDomain) {
+export function getFilterProps(
+ field: Field,
+ fieldDomain: FieldDomain
+): Partial<Filter> & {fieldType: string} {
const filterProps = {
...fieldDomain,
fieldType: field.type
@@ -317,11 +357,13 @@ export function getFilterProps(field, fieldDomain) {
...filterProps,
value: fieldDomain.domain,
type: FILTER_TYPES.range,
+ // @ts-expect-error
typeOptions: [FILTER_TYPES.range],
gpu: true
};
case ALL_FIELD_TYPES.boolean:
+ // @ts-expect-error
return {
...filterProps,
type: FILTER_TYPES.select,
@@ -331,6 +373,7 @@ export function getFilterProps(field, fieldDomain) {
case ALL_FIELD_TYPES.string:
case ALL_FIELD_TYPES.date:
+ // @ts-expect-error
return {
...filterProps,
type: FILTER_TYPES.multiSelect,
@@ -339,6 +382,7 @@ export function getFilterProps(field, fieldDomain) {
};
case ALL_FIELD_TYPES.timestamp:
+ // @ts-expect-error
return {
...filterProps,
type: FILTER_TYPES.timeRange,
@@ -349,6 +393,7 @@ export function getFilterProps(field, fieldDomain) {
};
default:
+ // @ts-expect-error
return {};
}
}
@@ -396,6 +441,12 @@ export const getPolygonFilterFunctor = (layer, filter, dataContainer) => {
}
};
+/**
+ * @param param An object that represents a row record.
+ * @param param.index Index of the row in data container.
+ * @returns Returns true to keep the element, or false otherwise.
+ */
+type filterFunction = (data: {index: number}) => boolean;
/**
* @param field dataset Field
* @param dataId Dataset id
@@ -403,9 +454,14 @@ export const getPolygonFilterFunctor = (layer, filter, dataContainer) => {
* @param layers list of layers to filter upon
* @param dataContainer Data container
* @return filterFunction
- * @type {typeof import('./filter-utils').getFilterFunction}
*/
-export function getFilterFunction(field, dataId, filter, layers, dataContainer) {
+export function getFilterFunction(
+ field: Field | null,
+ dataId: string,
+ filter: Filter,
+ layers: Layer[],
+ dataContainer: DataContainerInterface
+): filterFunction {
// field could be null in polygon filter
const valueAccessor = field ? field.valueAccessor : data => null;
const defaultFunc = d => true;
@@ -427,10 +483,9 @@ export function getFilterFunction(field, dataId, filter, layers, dataContainer)
: data => timeToUnixMilli(valueAccessor(data), field.format);
return data => isInRange(accessor(data), filter.value);
case FILTER_TYPES.polygon:
- if (!layers || !layers.length) {
+ if (!layers || !layers.length || !filter.layerId) {
return defaultFunc;
}
- // @ts-ignore
const layerFilterFunctions = filter.layerId
.map(id => layers.find(l => l.id === id))
.filter(l => l && l.config.dataId === dataId)
@@ -442,24 +497,29 @@ export function getFilterFunction(field, dataId, filter, layers, dataContainer)
}
}
-export function updateFilterDataId(dataId) {
+export function updateFilterDataId(dataId: string): FilterBase {
return getDefaultFilter(dataId);
}
-/**
- * @type {typeof import('./filter-utils').filterDataByFilterTypes}
- */
export function filterDataByFilterTypes(
- {dynamicDomainFilters, cpuFilters, filterFuncs},
- dataContainer
-) {
- const result = {
- ...(dynamicDomainFilters ? {filteredIndexForDomain: []} : {}),
- ...(cpuFilters ? {filteredIndex: []} : {})
- };
+ {
+ dynamicDomainFilters,
+ cpuFilters,
+ filterFuncs
+ }: {
+ dynamicDomainFilters: Filter[] | null;
+ cpuFilters: Filter[] | null;
+ filterFuncs: {
+ [key: string]: filterFunction;
+ };
+ },
+ dataContainer: DataContainerInterface
+): FilterResult {
+ const filteredIndexForDomain: number[] = [];
+ const filteredIndex: number[] = [];
const filterContext = {index: -1, dataContainer};
- const filterFuncCaller = filter => filterFuncs[filter.id](filterContext);
+ const filterFuncCaller = (filter: Filter) => filterFuncs[filter.id](filterContext);
const numRows = dataContainer.numRows();
for (let i = 0; i < numRows; ++i) {
@@ -467,29 +527,30 @@ export function filterDataByFilterTypes(
const matchForDomain = dynamicDomainFilters && dynamicDomainFilters.every(filterFuncCaller);
if (matchForDomain) {
- // @ts-ignore
- result.filteredIndexForDomain.push(filterContext.index);
+ filteredIndexForDomain.push(filterContext.index);
}
const matchForRender = cpuFilters && cpuFilters.every(filterFuncCaller);
if (matchForRender) {
- // @ts-ignore
- result.filteredIndex.push(filterContext.index);
+ filteredIndex.push(filterContext.index);
}
}
- return result;
+ return {
+ ...(dynamicDomainFilters ? {filteredIndexForDomain} : {}),
+ ...(cpuFilters ? {filteredIndex} : {})
+ };
}
/**
* Get a record of filters based on domain type and gpu / cpu
- * @type {typeof import('./filter-utils').getFilterRecord}
*/
-export function getFilterRecord(dataId, filters, opt = {}) {
- /**
- * @type {FilterRecord}
- */
- const filterRecord = {
+export function getFilterRecord(
+ dataId: string,
+ filters: Filter[],
+ opt: FilterDatasetOpt = {}
+): FilterRecord {
+ const filterRecord: FilterRecord = {
dynamicDomain: [],
fixedDomain: [],
cpu: [],
@@ -512,14 +573,18 @@ export function getFilterRecord(dataId, filters, opt = {}) {
/**
* Compare filter records to get what has changed
- * @type {typeof import('./filter-utils').diffFilters}
*/
-export function diffFilters(filterRecord, oldFilterRecord = {}) {
- let filterChanged = {};
+export function diffFilters(
+ filterRecord: FilterRecord,
+ oldFilterRecord: FilterRecord | {} = {}
+): FilterChanged {
+ let filterChanged: Partial<FilterChanged> = {};
- Object.entries(filterRecord).forEach(([record, items]) => {
+ (Object.entries(filterRecord) as Entries<FilterRecord>).forEach(([record, items]) => {
items.forEach(filter => {
- const oldFilter = (oldFilterRecord[record] || []).find(f => f.id === filter.id);
+ const oldFilter: Filter = (oldFilterRecord[record] || []).find(
+ (f: Filter) => f.id === filter.id
+ );
if (!oldFilter) {
// added
@@ -534,31 +599,25 @@ export function diffFilters(filterRecord, oldFilterRecord = {}) {
}
});
- (oldFilterRecord[record] || []).forEach(oldFilter => {
+ (oldFilterRecord[record] || []).forEach((oldFilter: Filter) => {
// deleted
if (!items.find(f => f.id === oldFilter.id)) {
filterChanged = set([record, oldFilter.id], 'deleted', filterChanged);
}
});
-
- if (!filterChanged[record]) {
- filterChanged[record] = null;
- }
});
- // @ts-ignore
- return filterChanged;
+ return {...{dynamicDomain: null, fixedDomain: null, cpu: null, gpu: null}, ...filterChanged};
}
/**
* Call by parsing filters from URL
* Check if value of filter within filter domain, if not adjust it to match
* filter domain
*
- * @type {typeof import('./filter-utils').adjustValueToFilterDomain}
* @returns value - adjusted value to match filter or null to remove filter
*/
/* eslint-disable complexity */
-export function adjustValueToFilterDomain(value, {domain, type}) {
+export function adjustValueToFilterDomain(value: Filter['value'], {domain, type}) {
if (!domain || !type) {
return false;
}
@@ -590,11 +649,12 @@ export function adjustValueToFilterDomain(value, {domain, type}) {
/**
* Calculate numeric domain and suitable step
- *
- * @type {typeof import('./filter-utils').getNumericFieldDomain}
*/
-export function getNumericFieldDomain(dataContainer, valueAccessor) {
- let domain = [0, 1];
+export function getNumericFieldDomain(
+ dataContainer: DataContainerInterface,
+ valueAccessor: dataValueAccessor
+): RangeFieldDomain {
+ let domain: [number, number] = [0, 1];
let step = 0.1;
const mappedValue = dataContainer.mapIndex(valueAccessor);
@@ -613,7 +673,6 @@ export function getNumericFieldDomain(dataContainer, valueAccessor) {
domain[1] = formatNumberByStep(domain[1], step, 'ceil');
}
- // @ts-ignore
const {histogram, enlargedHistogram} = getHistogram(domain, mappedValue);
return {domain, step, histogram, enlargedHistogram};
@@ -621,10 +680,8 @@ export function getNumericFieldDomain(dataContainer, valueAccessor) {
/**
* Calculate step size for range and timerange filter
- *
- * @type {typeof import('./filter-utils').getNumericStepSize}
*/
-export function getNumericStepSize(diff) {
+export function getNumericStepSize(diff: number): number {
diff = Math.abs(diff);
if (diff > 100) {
@@ -652,9 +709,11 @@ export function getNumericStepSize(diff) {
/**
* Calculate timestamp domain and suitable step
- * @type {typeof import('./filter-utils').getTimestampFieldDomain}
*/
-export function getTimestampFieldDomain(dataContainer, valueAccessor) {
+export function getTimestampFieldDomain(
+ dataContainer: DataContainerInterface,
+ valueAccessor: dataValueAccessor
+): TimeRangeFieldDomain {
// to avoid converting string format time to epoch
// every time we compare we store a value mapped to int in filter domain
@@ -682,11 +741,11 @@ export function getTimestampFieldDomain(dataContainer, valueAccessor) {
};
}
-/**
- *
- * @type {typeof import('./filter-utils').histogramConstruct}
- */
-export function histogramConstruct(domain, mappedValue, bins) {
+export function histogramConstruct(
+ domain: [number, number],
+ mappedValue: (Millisecond | number)[],
+ bins: number
+): HistogramBin[] {
return d3Histogram()
.thresholds(ticks(domain[0], domain[1], bins))
.domain(domain)(mappedValue)
@@ -698,10 +757,11 @@ export function histogramConstruct(domain, mappedValue, bins) {
}
/**
* Calculate histogram from domain and array of values
- *
- * @type {typeof import('./filter-utils').getHistogram}
*/
-export function getHistogram(domain, mappedValue) {
+export function getHistogram(
+ domain: [number, number],
+ mappedValue: (Millisecond | number)[]
+): {histogram: HistogramBin[]; enlargedHistogram: HistogramBin[]} {
const histogram = histogramConstruct(domain, mappedValue, histogramBins);
const enlargedHistogram = histogramConstruct(domain, mappedValue, enlargedHistogramBins);
@@ -716,7 +776,7 @@ export function getHistogram(domain, mappedValue) {
* @param {string} bound
* @returns {Number} rounded number
*/
-export function formatNumberByStep(val, step, bound) {
+export function formatNumberByStep(val: number, step: number, bound: 'floor' | 'ceil'): number {
if (bound === 'floor') {
return Math.floor(val * (1 / step)) / (1 / step);
}
@@ -724,11 +784,7 @@ export function formatNumberByStep(val, step, bound) {
return Math.ceil(val * (1 / step)) / (1 / step);
}
-/**
- *
- * @type {typeof import('./filter-utils').isInRange}
- */
-export function isInRange(val, domain) {
+export function isInRange(val: any, domain: number[]): boolean {
if (!Array.isArray(domain)) {
return false;
}
@@ -743,13 +799,13 @@ export function isInRange(val, domain) {
* @param polygon Points must be within these (Multi)Polygon(s)
* @return {boolean}
*/
-export function isInPolygon(point, polygon) {
+export function isInPolygon(point: number[], polygon: any): boolean {
return booleanWithin(turfPoint(point), polygon);
}
export function isValidTimeDomain(domain) {
return Array.isArray(domain) && domain.every(Number.isFinite);
}
-export function getTimeWidgetTitleFormatter(domain) {
+export function getTimeWidgetTitleFormatter(domain: [number, number]): string | null {
if (!isValidTimeDomain(domain)) {
return null;
}
@@ -761,9 +817,9 @@ export function getTimeWidgetTitleFormatter(domain) {
return diff > durationYear ? 'L' : diff > durationDay ? 'L LT' : 'L LTS';
}
-export function getTimeWidgetHintFormatter(domain) {
+export function getTimeWidgetHintFormatter(domain: [number, number]): string | undefined {
if (!isValidTimeDomain(domain)) {
- return null;
+ return undefined;
}
const diff = domain[1] - domain[0];
@@ -778,10 +834,9 @@ export function getTimeWidgetHintFormatter(domain) {
/**
* Sanity check on filters to prepare for save
- * @type {typeof import('./filter-utils').isValidFilterValue}
*/
/* eslint-disable complexity */
-export function isValidFilterValue(type, value) {
+export function isValidFilterValue(type: string | null, value: any): boolean {
if (!type) {
return false;
}
@@ -808,11 +863,10 @@ export function isValidFilterValue(type, value) {
}
}
-/**
- *
- * @type {typeof import('./filter-utils').getFilterPlot}
- */
-export function getFilterPlot(filter, dataset) {
+export function getFilterPlot(
+ filter: Filter,
+ dataset: KeplerTable
+): {lineChart: LineChart; yAxs: Field} | {} {
if (filter.plotType === PLOT_TYPES.histogram || !filter.yAxis) {
// histogram should be calculated when create filter
return {};
@@ -844,8 +898,9 @@ export function getFilterPlot(filter, dataset) {
return {lineChart: {series, yDomain, xDomain}, yAxis};
}
-export function getDefaultFilterPlotType(filter) {
- const filterPlotTypes = SupportedPlotType[filter.type];
+export function getDefaultFilterPlotType(filter: Filter): string | null {
+ const filterPlotTypes: typeof SupportedPlotType[keyof typeof SupportedPlotType] | null =
+ filter.type && SupportedPlotType[filter.type];
if (!filterPlotTypes) {
return null;
}
@@ -863,9 +918,13 @@ export function getDefaultFilterPlotType(filter) {
* @param datasets all datasets
* @param filters all filters to be applied to datasets
* @return datasets - new updated datasets
- * @type {typeof import('./filter-utils').applyFiltersToDatasets}
*/
-export function applyFiltersToDatasets(datasetIds, datasets, filters, layers) {
+export function applyFiltersToDatasets(
+ datasetIds: string[],
+ datasets: Datasets,
+ filters: Filter[],
+ layers?: Layer[]
+): Datasets {
const dataIds = toArray(datasetIds);
return dataIds.reduce((acc, dataId) => {
const layersToFilter = (layers || []).filter(l => l.config.dataId === dataId);
@@ -887,9 +946,17 @@ export function applyFiltersToDatasets(datasetIds, datasets, filters, layers) {
* @param filterDatasetIndex - field.name
* @param option
* @return - {filter, datasets}
- * @type {typeof import('./filter-utils').applyFilterFieldName}
*/
-export function applyFilterFieldName(filter, dataset, fieldName, filterDatasetIndex = 0, option) {
+export function applyFilterFieldName(
+ filter: Filter,
+ dataset: KeplerTable,
+ fieldName: string,
+ filterDatasetIndex = 0,
+ option?: {mergeDomain: boolean}
+): {
+ filter: Filter | null;
+ dataset: KeplerTable;
+} {
// using filterDatasetIndex we can filter only the specified dataset
const mergeDomain = option && option.hasOwnProperty('mergeDomain') ? option.mergeDomain : false;
@@ -921,10 +988,9 @@ export function applyFilterFieldName(filter, dataset, fieldName, filterDatasetIn
/**
* Merge one filter with other filter prop domain
- * @type {typeof import('./filter-utils').mergeFilterDomainStep}
*/
/* eslint-disable complexity */
-export function mergeFilterDomainStep(filter, filterProps) {
+export function mergeFilterDomainStep(filter: Filter, filterProps?: any): Filter | null {
if (!filter) {
return null;
}
@@ -956,8 +1022,10 @@ export function mergeFilterDomainStep(filter, filterProps) {
};
case ALL_FIELD_TYPES.timestamp:
- // @ts-ignore
- const step = filter.step < filterProps.step ? filter.step : filterProps.step;
+ const step =
+ (filter as TimeRangeFilter).step < filterProps.step
+ ? (filter as TimeRangeFilter).step
+ : filterProps.step;
return {
...newFilter,
@@ -973,9 +1041,12 @@ export function mergeFilterDomainStep(filter, filterProps) {
/**
* Generates polygon filter
- * @type {typeof import('./filter-utils').featureToFilterValue}
*/
-export const featureToFilterValue = (feature, filterId, properties = {}) => ({
+export const featureToFilterValue = (
+ feature: Feature,
+ filterId: string,
+ properties?: {}
+): FeatureValue => ({
...feature,
id: feature.id,
properties: {
@@ -985,20 +1056,15 @@ export const featureToFilterValue = (feature, filterId, properties = {}) => ({
}
});
-/**
- * @type {typeof import('./filter-utils').getFilterIdInFeature}
- */
-export const getFilterIdInFeature = f => get(f, ['properties', 'filterId']);
+export const getFilterIdInFeature = (f: FeatureValue): string => get(f, ['properties', 'filterId']);
/**
* Generates polygon filter
- * @type {typeof import('./filter-utils').generatePolygonFilter}
*/
-export function generatePolygonFilter(layers, feature) {
- const dataId = layers.map(l => l.config.dataId).filter(d => d);
+export function generatePolygonFilter(layers: Layer[], feature: Feature): PolygonFilter {
+ const dataId = layers.map(l => l.config.dataId).filter(notNullorUndefined);
const layerId = layers.map(l => l.id);
const name = layers.map(l => l.config.label);
- // @ts-ignore
const filter = getDefaultFilter(dataId);
return {
...filter,
@@ -1012,9 +1078,8 @@ export function generatePolygonFilter(layers, feature) {
/**
* Run filter entirely on CPU
- * @type {typeof import('./filter-utils').filterDatasetCPU}
*/
-export function filterDatasetCPU(state, dataId) {
+export function filterDatasetCPU(state: VisState, dataId: string): VisState {
const datasetFilters = state.filters.filter(f => f.dataId.includes(dataId));
const dataset = state.datasets[dataId];
@@ -1029,11 +1094,18 @@ export function filterDatasetCPU(state, dataId) {
/**
* Validate parsed filters with datasets and add filterProps to field
- * @type {typeof import('./filter-utils').validateFiltersUpdateDatasets}
*/
-export function validateFiltersUpdateDatasets(state, filtersToValidate = []) {
- const validated = [];
- const failed = [];
+export function validateFiltersUpdateDatasets(
+ state: VisState,
+ filtersToValidate: ParsedFilter[] = []
+): {
+ validated: Filter[];
+ failed: Filter[];
+ updatedDatasets: Datasets;
+} {
+ // TODO Better Typings here
+ const validated: any[] = [];
+ const failed: any[] = [];
const {datasets} = state;
let updatedDatasets = datasets;
@@ -1101,9 +1173,8 @@ export function validateFiltersUpdateDatasets(state, filtersToValidate = []) {
/**
* Retrieve interval bins for time filter
- * @type {typeof import('./filter-utils').getIntervalBins}
*/
-export function getIntervalBins(filter) {
+export function getIntervalBins(filter: TimeRangeFilter) {
const {bins} = filter;
const interval = filter.plotType?.interval;
if (!interval || !bins || Object.keys(bins).length === 0) {
diff --git a/src/utils/gpu-filter-utils.d.ts b/src/utils/gpu-filter-utils.d.ts
deleted file mode 100644
index 3dcda5d8e..000000000
--- a/src/utils/gpu-filter-utils.d.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-// 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;
diff --git a/src/utils/gpu-filter-utils.js b/src/utils/gpu-filter-utils.ts
similarity index 81%
rename from src/utils/gpu-filter-utils.js
rename to src/utils/gpu-filter-utils.ts
index 4ed7944ad..7aefc0293 100644
--- a/src/utils/gpu-filter-utils.js
+++ b/src/utils/gpu-filter-utils.ts
@@ -22,12 +22,14 @@ import {set, toArray} from './utils';
import {MAX_GPU_FILTERS, FILTER_TYPES} from 'constants/default-settings';
import {notNullorUndefined} from './data-utils';
import moment from 'moment';
+import {Filter} from 'reducers/vis-state-updaters';
+import {DataContainerInterface} from './table-utils/data-container-interface';
+import {Field, GpuFilter} from './table-utils/kepler-table';
/**
* Set gpu mode based on current number of gpu filters exists
- * @type {typeof import('./gpu-filter-utils').setFilterGpuMode}
*/
-export function setFilterGpuMode(filter, filters) {
+export function setFilterGpuMode(filter: Filter, filters: Filter[]) {
// 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
@@ -46,9 +48,8 @@ export function setFilterGpuMode(filter, filters) {
/**
* Scan though all filters and assign gpu chanel to gpu filter
- * @type {typeof import('./gpu-filter-utils').assignGpuChannels}
*/
-export function assignGpuChannels(allFilters) {
+export function assignGpuChannels(allFilters: Filter[]) {
return allFilters.reduce((accu, f, index) => {
let filters = accu;
@@ -63,9 +64,8 @@ export function assignGpuChannels(allFilters) {
}
/**
* Assign a new gpu filter a channel based on first availability
- * @type {typeof import('./gpu-filter-utils').assignGpuChannel}
*/
-export function assignGpuChannel(filter, filters) {
+export function assignGpuChannel(filter: Filter, filters: Filter[]) {
// find first available channel
if (!filter.gpu) {
return filter;
@@ -117,9 +117,8 @@ export function assignGpuChannel(filter, filters) {
/**
* 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) {
+export function resetFilterGpuMode(filters: Filter[]): Filter[] {
const gpuPerDataset = {};
return filters.map((f, i) => {
@@ -146,7 +145,6 @@ export function resetFilterGpuMode(filters) {
/**
* Initial filter uniform
- * @returns {Array<Array<Number>>}
*/
function getEmptyFilterRange() {
return new Array(MAX_GPU_FILTERS).fill(0).map(d => [0, 0]);
@@ -161,25 +159,26 @@ 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.
+ * @param dc Data container.
+ * @param d Data element with row index info.
+ * @param fieldIndex Column index in the data container.
* @returns
*/
-const defaultGetData = (dc, d, fieldIndex) => {
+const defaultGetData = (dc: DataContainerInterface, d: any, fieldIndex: number) => {
return dc.valueAt(d.index, fieldIndex);
};
/**
- * @param {Array<Object>} channels
- * @param {string} dataId
- * @param {Array<Object>} fields
+ * @param channels
+ * @param dataId
+ * @param fields
* @return {Function} getFilterValue
*/
-const getFilterValueAccessor = (channels, dataId, fields) => dc => (
- getIndex = defaultGetIndex,
- getData = defaultGetData
-) => d =>
+const getFilterValueAccessor = (
+ channels: (Filter | undefined)[],
+ dataId: string,
+ fields: any[]
+) => (dc: DataContainerInterface) => (getIndex = defaultGetIndex, getData = defaultGetData) => d =>
// for empty channel, value is 0 and min max would be [0, 0]
channels.map(filter => {
if (!filter) {
@@ -195,19 +194,18 @@ const getFilterValueAccessor = (channels, dataId, fields) => dc => (
: moment.utc(getData(dc, d, fieldIndex)).valueOf()
: getData(dc, d, fieldIndex);
- return notNullorUndefined(value) ? value - filter.domain[0] : Number.MIN_SAFE_INTEGER;
+ 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) {
+export function getGpuFilterProps(filters: Filter[], dataId: string, fields: Field[]): GpuFilter {
const filterRange = getEmptyFilterRange();
const triggers = {};
// array of filter for each channel, undefined, if no filter is assigned to that channel
- const channels = [];
+ const channels: (Filter | undefined)[] = [];
for (let i = 0; i < MAX_GPU_FILTERS; i++) {
const filter = filters.find(
@@ -218,10 +216,8 @@ export function getGpuFilterProps(filters, dataId, fields) {
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;
+ filterRange[i][0] = filter ? filter.value[0] - filter.domain?.[0] : 0;
+ 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);
@@ -232,6 +228,7 @@ export function getGpuFilterProps(filters, dataId, fields) {
return {
filterRange,
filterValueUpdateTriggers: triggers,
+ // @ts-expect-error
filterValueAccessor
};
}
@@ -239,9 +236,8 @@ export function getGpuFilterProps(filters, dataId, fields) {
/**
* 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) {
+export function getDatasetFieldIndexForFilter(dataId: string, filter: Filter): number {
const datasetIndex = toArray(filter.dataId).indexOf(dataId);
if (datasetIndex < 0) {
return -1;
diff --git a/src/utils/table-utils/kepler-table.js b/src/utils/table-utils/kepler-table.js
index a11997630..2d3641115 100644
--- a/src/utils/table-utils/kepler-table.js
+++ b/src/utils/table-utils/kepler-table.js
@@ -173,6 +173,7 @@ class KeplerTable {
return null;
}
+ // @ts-expect-error
const filterProps = getFilterProps(field, fieldDomain);
const newField = {
...field,