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.tsindex 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.tsdeleted file mode 100644index 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.tssimilarity index 78%rename from src/utils/filter-utils.jsrename to src/utils/filter-utils.tsindex 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.dataIdconst 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-errortypeOptions: [FILTER_TYPES.range],gpu: true};case ALL_FIELD_TYPES.boolean:+ // @ts-expect-errorreturn {...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-errorreturn {...filterProps,type: FILTER_TYPES.multiSelect,@@ -339,6 +382,7 @@ export function getFilterProps(field, fieldDomain) {};case ALL_FIELD_TYPES.timestamp:+ // @ts-expect-errorreturn {...filterProps,type: FILTER_TYPES.timeRange,@@ -349,6 +393,7 @@ export function getFilterProps(field, fieldDomain) {};default:+ // @ts-expect-errorreturn {};}}@@ -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 filterconst 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-ignoreconst 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) => {// deletedif (!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-ignoreconst {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 filterreturn {};@@ -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 datasetconst 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-ignoreconst 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.tsdeleted file mode 100644index 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.tssimilarity index 81%rename from src/utils/gpu-filter-utils.jsrename to src/utils/gpu-filter-utils.tsindex 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 channelif (!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-errorfilterValueAccessor};}@@ -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.jsindex 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-errorconst filterProps = getFilterProps(field, fieldDomain);const newField = {...field,