kepler.gl
Version:
kepler.gl is a webgl based application to visualize large scale location data in the browser
327 lines (326 loc) • 11.4 kB
TypeScript
import { VisState } from '@kepler.gl/schemas';
import { Millisecond, Field, ParsedFilter, Filter, FilterBase, PolygonFilter, FieldDomain, TimeRangeFieldDomain, HistogramBin, Feature, FeatureValue, LineChart, TimeRangeFilter, RangeFieldDomain, FilterDatasetOpt, FilterRecord } from '@kepler.gl/types';
import { DataContainerInterface } from './data-container-interface';
export declare const durationSecond = 1000;
export declare const durationMinute: number;
export declare const durationHour: number;
export declare const durationDay: number;
export declare const durationWeek: number;
export declare const durationYear: number;
export declare type FilterResult = {
filteredIndexForDomain?: number[];
filteredIndex?: number[];
};
export declare type FilterChanged = {
[key in keyof FilterRecord]: {
[key: string]: 'added' | 'deleted' | 'name_changed' | 'value_changed' | 'dataId_changed';
} | null;
};
export declare type dataValueAccessor = (data: {
index: number;
}) => number | null;
export declare const TimestampStepMap: {
max: number;
step: number;
}[];
export declare const histogramBins = 30;
export declare const enlargedHistogramBins = 100;
export declare const FILTER_UPDATER_PROPS: {
dataId: "dataId";
name: "name";
layerId: "layerId";
};
export declare const LIMITED_FILTER_EFFECT_PROPS: {
name: "name";
};
export declare const FILTER_COMPONENTS: {
select: string;
multiSelect: string;
timeRange: string;
range: string;
polygon: string;
};
export declare const DEFAULT_FILTER_STRUCTURE: {
dataId: never[];
freeze: boolean;
id: null;
enabled: boolean;
fixedDomain: boolean;
view: "side";
isAnimating: boolean;
animationWindow: "free";
speed: number;
name: never[];
type: null;
fieldIdx: never[];
domain: null;
value: null;
plotType: "histogram";
yAxis: null;
interval: null;
gpu: boolean;
};
export declare const FILTER_ID_LENGTH = 4;
export declare const LAYER_FILTERS: "polygon"[];
/**
* Generates a filter with a dataset id as dataId
*/
export declare function getDefaultFilter({ dataId, id }?: {
dataId?: string | null | string[];
id?: string;
}): FilterBase<LineChart>;
/**
* Check if a filter is valid based on the given dataId
* @param filter to validate
* @param datasetId id to validate filter against
* @return true if a filter is valid, false otherwise
*/
export declare function shouldApplyFilter(filter: Filter, datasetId: string): boolean;
interface KeplerTableModel<K, L> {
id: string;
getColumnFieldIdx(columnName: string): number;
filterTable(filters: Filter[], layers: L[], opt?: FilterDatasetOpt): K;
getColumnFilterProps(columnName: string): Field['filterProps'] | null | undefined;
dataContainer: DataContainerInterface;
filterTableCPU(filters: Filter[], layers: L[]): K;
}
/**
* Validates and modifies polygon filter structure
* @param dataset
* @param filter
* @param layers
* @return - {filter, dataset}
*/
export declare function validatePolygonFilter<K extends KeplerTableModel<K, L>, L extends {
id: string;
}>(dataset: K, filter: PolygonFilter, layers: L[]): {
filter: PolygonFilter | null;
dataset: K;
};
/**
* Default validate filter function
* @param dataset
* @param filter
* @return - {filter, dataset}
*/
export declare function validateFilter<K extends KeplerTableModel<K, L>, L>(dataset: K, filter: ParsedFilter): {
filter: Filter | null;
dataset: K;
};
/**
* Validate saved filter config with new data,
* calculate domain and fieldIdx based new fields and data
*
* @param dataset
* @param filter - filter to be validate
* @param layers - layers
* @return validated filter
*/
export declare function validateFilterWithData<K extends KeplerTableModel<K, L>, L>(dataset: K, filter: ParsedFilter, layers: L[]): {
filter: Filter;
dataset: K;
};
/**
* Get default filter prop based on field type
*
* @param field
* @param fieldDomain
* @returns default filter
*/
export declare function getFilterProps(field: Field, fieldDomain: FieldDomain): Partial<Filter> & {
fieldType: string;
};
export declare const getPolygonFilterFunctor: (layer: any, filter: any, dataContainer: any) => (data: any) => any;
/**
* @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.
*/
declare type filterFunction = (data: {
index: number;
}) => boolean;
/**
* @param field dataset Field
* @param dataId Dataset id
* @param filter Filter object
* @param layers list of layers to filter upon
* @param dataContainer Data container
* @return filterFunction
*/
export declare function getFilterFunction<L extends {
config: {
dataId: string | null;
};
id: string;
}>(field: Field | null, dataId: string, filter: Filter, layers: L[], dataContainer: DataContainerInterface): filterFunction;
export declare function updateFilterDataId(dataId: string | string[]): FilterBase<LineChart>;
export declare function filterDataByFilterTypes({ dynamicDomainFilters, cpuFilters, filterFuncs }: {
dynamicDomainFilters: Filter[] | null;
cpuFilters: Filter[] | null;
filterFuncs: {
[key: string]: filterFunction;
};
}, dataContainer: DataContainerInterface): FilterResult;
/**
* Get a record of filters based on domain type and gpu / cpu
*/
export declare function getFilterRecord(dataId: string, filters: Filter[], opt?: FilterDatasetOpt): FilterRecord;
/**
* Compare filter records to get what has changed
*/
export declare function diffFilters(filterRecord: FilterRecord, oldFilterRecord?: FilterRecord | {}): FilterChanged;
/**
* Call by parsing filters from URL
* Check if value of filter within filter domain, if not adjust it to match
* filter domain
*
* @returns value - adjusted value to match filter or null to remove filter
*/
export declare function adjustValueToFilterDomain(value: Filter['value'], { domain, type }: {
domain: any;
type: any;
}): any;
/**
* Calculate numeric domain and suitable step
*/
export declare function getNumericFieldDomain(dataContainer: DataContainerInterface, valueAccessor: dataValueAccessor): RangeFieldDomain;
/**
* Calculate step size for range and timerange filter
*/
export declare function getNumericStepSize(diff: number): number;
/**
* Calculate timestamp domain and suitable step
*/
export declare function getTimestampFieldDomain(dataContainer: DataContainerInterface, valueAccessor: dataValueAccessor): TimeRangeFieldDomain;
export declare function histogramConstruct(domain: [number, number], mappedValue: (Millisecond | number)[], bins: number): HistogramBin[];
/**
* Calculate histogram from domain and array of values
*/
export declare function getHistogram(domain: [number, number], mappedValue: (Millisecond | number)[]): {
histogram: HistogramBin[];
enlargedHistogram: HistogramBin[];
};
/**
* round number based on step
*
* @param {Number} val
* @param {Number} step
* @param {string} bound
* @returns {Number} rounded number
*/
export declare function formatNumberByStep(val: number, step: number, bound: 'floor' | 'ceil'): number;
export declare function isInRange(val: any, domain: number[]): boolean;
/**
* Determines whether a point is within the provided polygon
*
* @param point as input search [lat, lng]
* @param polygon Points must be within these (Multi)Polygon(s)
* @return {boolean}
*/
export declare function isInPolygon(point: number[], polygon: any): boolean;
export declare function getTimeWidgetTitleFormatter(domain: [number, number]): string | null;
/**
* Sanity check on filters to prepare for save
* @type {typeof import('./filter-utils').isFilterValidToSave}
*/
export declare function isFilterValidToSave(filter: any): boolean;
/**
* Sanity check on filters to prepare for save
* @type {typeof import('./filter-utils').isValidFilterValue}
*/
export declare function isValidFilterValue(type: string | null, value: any): boolean;
export declare function getColumnFilterProps<K extends KeplerTableModel<K, L>, L>(filter: Filter, dataset: K): {
lineChart: LineChart;
yAxs: Field;
} | {};
export declare function getDefaultFilterPlotType(filter: Filter): string | null;
/**
*
* @param datasetIds list of dataset ids to be filtered
* @param datasets all datasets
* @param filters all filters to be applied to datasets
* @return datasets - new updated datasets
*/
export declare function applyFiltersToDatasets<K extends KeplerTableModel<K, L>, L extends {
config: {
dataId: string | null;
};
}>(datasetIds: string[], datasets: {
[id: string]: K;
}, filters: Filter[], layers?: L[]): {
[id: string]: K;
};
/**
* Applies a new field name value to fielter and update both filter and dataset
* @param filter - to be applied the new field name on
* @param dataset - dataset the field belongs to
* @param fieldName - field.name
* @param filterDatasetIndex - field.name
* @param option
* @return - {filter, datasets}
*/
export declare function applyFilterFieldName<K extends KeplerTableModel<K, L>, L>(filter: Filter, dataset: K, fieldName: string, filterDatasetIndex?: number, option?: {
mergeDomain: boolean;
}): {
filter: Filter | null;
dataset: K;
};
/**
* Merge one filter with other filter prop domain
*/
export declare function mergeFilterDomainStep(filter: Filter, filterProps?: Partial<Filter>): (Filter & {
step?: number;
}) | null;
/**
* Generates polygon filter
*/
export declare const featureToFilterValue: (feature: Feature, filterId: string, properties?: {} | undefined) => FeatureValue;
export declare const getFilterIdInFeature: (f: FeatureValue) => string;
/**
* Generates polygon filter
*/
export declare function generatePolygonFilter<L extends {
config: {
dataId: string | null;
label: string;
};
id: string;
}>(layers: L[], feature: Feature): PolygonFilter;
/**
* Run filter entirely on CPU
*/
interface StateType<K extends KeplerTableModel<K, L>, L> {
layers: L[];
filters: Filter[];
datasets: {
[id: string]: K;
};
}
export declare function filterDatasetCPU<T extends StateType<K, L>, K extends KeplerTableModel<K, L>, L>(state: T, dataId: string): T;
/**
* Validate parsed filters with datasets and add filterProps to field
*/
declare type MinVisStateForFilter = Pick<VisState, 'layers' | 'datasets' | 'isMergingDatasets'>;
export declare function validateFiltersUpdateDatasets<S extends MinVisStateForFilter, K extends KeplerTableModel<K, L>, L extends {
config: {
dataId: string | null;
label: string;
};
id: string;
}>(state: S, filtersToValidate?: ParsedFilter[]): {
validated: Filter[];
failed: Filter[];
updatedDatasets: S['datasets'];
};
export declare function getFilterPlot<K extends KeplerTableModel<K, L>, L>(filter: Filter, dataset: K): {
lineChart: LineChart;
yAxs: Field;
} | {};
/**
* Retrieve interval bins for time filter
*/
export declare function getIntervalBins(filter: TimeRangeFilter): any;
export declare function isValidTimeDomain(domain: any): boolean;
export declare function getTimeWidgetHintFormatter(domain: [number, number]): string | undefined;
export declare function isSideFilter(filter: Filter): boolean;
export {};