@carto/api-client 0.4.3 → 0.5.0-alpha.0

package/src/filters/Filter.ts

@@ -0,0 +1,169 @@
+import {filterFunctions} from './FilterTypes';
+import {Filter, FilterLogicalOperator, Filters} from '../types';
+import {Feature} from 'geojson';
+import {FilterType} from '../constants';
+import {FeatureData} from '../types-internal';
+import {BinaryFeature} from '@loaders.gl/schema';
+
+const LOGICAL_OPERATOR_METHODS: Record<
+  FilterLogicalOperator,
+  'every' | 'some'
+> = {
+  and: 'every',
+  or: 'some',
+};
+
+function passesFilter(
+  columns: string[],
+  filters: Filters,
+  feature: FeatureData,
+  filtersLogicalOperator: FilterLogicalOperator
+): boolean {
+  const method = LOGICAL_OPERATOR_METHODS[filtersLogicalOperator];
+  return columns[method]((column) => {
+    const columnFilters = filters[column];
+    const columnFilterTypes = Object.keys(columnFilters) as FilterType[];
+
+    if (!feature || feature[column] === null || feature[column] === undefined) {
+      return false;
+    }
+
+    return columnFilterTypes.every((filter) => {
+      const filterFunction = filterFunctions[filter];
+
+      if (!filterFunction) {
+        throw new Error(`"${filter}" filter is not implemented.`);
+      }
+
+      return filterFunction(
+        columnFilters[filter]!.values,
+        feature[column],
+        (columnFilters[filter] as Filter[FilterType.STRING_SEARCH])!.params
+      );
+    });
+  });
+}
+
+export function buildFeatureFilter({
+  filters = {},
+  type = 'boolean',
+  filtersLogicalOperator = 'and',
+}: {
+  filters?: Filters;
+  type?: 'number' | 'boolean';
+  filtersLogicalOperator?: FilterLogicalOperator;
+}) {
+  const columns = Object.keys(filters);
+
+  if (!columns.length) {
+    return () => (type === 'number' ? 1 : true);
+  }
+
+  return (feature: Feature | FeatureData) => {
+    const f = feature.properties || feature;
+    const featurePassesFilter = passesFilter(
+      columns,
+      filters,
+      f as FeatureData,
+      filtersLogicalOperator
+    );
+
+    return type === 'number'
+      ? Number(featurePassesFilter)
+      : featurePassesFilter;
+  };
+}
+
+// Apply certain filters to a collection of features
+export function applyFilters(
+  features: FeatureData[],
+  filters: Filters,
+  filtersLogicalOperator: FilterLogicalOperator
+) {
+  return Object.keys(filters).length
+    ? features.filter(buildFeatureFilter({filters, filtersLogicalOperator}))
+    : features;
+}
+
+// Binary
+export function buildBinaryFeatureFilter({filters = {}}: {filters: Filters}) {
+  const columns = Object.keys(filters);
+
+  if (!columns.length) {
+    return () => 1;
+  }
+
+  return (featureIdIdx: number, binaryData: BinaryFeature) =>
+    passesFilterUsingBinary(columns, filters, featureIdIdx, binaryData);
+}
+
+function getValueFromNumericProps(
+  featureIdIdx: number,
+  binaryData: BinaryFeature,
+  {column}: {column: string}
+) {
+  return binaryData.numericProps?.[column]?.value[featureIdIdx];
+}
+
+function getValueFromProperties(
+  featureIdIdx: number,
+  binaryData: BinaryFeature,
+  {column}: {column: string}
+) {
+  const propertyIdx = binaryData.featureIds.value[featureIdIdx];
+  return (binaryData.properties[propertyIdx] as Record<string, unknown>)?.[
+    column
+  ];
+}
+
+const GET_VALUE_BY_BINARY_PROP = {
+  properties: getValueFromProperties,
+  numericProps: getValueFromNumericProps,
+};
+
+function getBinaryPropertyByFilterValues(filterValues: unknown[]) {
+  return typeof filterValues.flat()[0] === 'string'
+    ? 'properties'
+    : 'numericProps';
+}
+
+function getFeatureValue(
+  featureIdIdx: number,
+  binaryData: any,
+  filter: {type: FilterType; column: string; values: unknown[]}
+) {
+  const {column, values} = filter;
+  const binaryProp = getBinaryPropertyByFilterValues(values);
+  const getFeatureValueFn = GET_VALUE_BY_BINARY_PROP[binaryProp];
+  return getFeatureValueFn(featureIdIdx, binaryData, {column});
+}
+
+function passesFilterUsingBinary(
+  columns: string[],
+  filters: Filters,
+  featureIdIdx: number,
+  binaryData: BinaryFeature
+) {
+  return columns.every((column) => {
+    const columnFilters = filters[column];
+
+    return Object.entries(columnFilters).every(([type, {values}]) => {
+      const filterFn = filterFunctions[type as FilterType];
+      if (!filterFn) {
+        throw new Error(`"${type}" filter is not implemented.`);
+      }
+
+      if (!values) return 0;
+
+      const featureValue = getFeatureValue(featureIdIdx, binaryData, {
+        type: type as FilterType,
+        column,
+        values,
+      });
+
+      if (featureValue === undefined || featureValue === null) return 0;
+
+      return filterFn(values, featureValue);
+    });
+  });
+}

package/src/filters/FilterTypes.ts

@@ -0,0 +1,109 @@
+import {FilterType} from '../constants';
+import {FilterInterval, StringSearchOptions} from '../types';
+import {makeIntervalComplete} from '../utils/makeIntervalComplete.js';
+
+export type FilterFunction = (
+  filterValues: unknown[],
+  featureValue: unknown,
+  params?: Record<string, unknown>
+) => boolean;
+
+export const filterFunctions: Record<FilterType, FilterFunction> = {
+  [FilterType.IN]: filterIn,
+  [FilterType.BETWEEN]: filterBetween,
+  [FilterType.TIME]: filterTime,
+  [FilterType.CLOSED_OPEN]: filterClosedOpen,
+  [FilterType.STRING_SEARCH]: filterStringSearch,
+};
+
+function filterIn(filterValues: unknown[], featureValue: unknown): boolean {
+  return filterValues.includes(featureValue);
+}
+
+// FilterTypes.BETWEEN
+function filterBetween(
+  filterValues: unknown[],
+  featureValue: unknown
+): boolean {
+  const checkRange = (range: [number, number]) => {
+    const [lowerBound, upperBound] = range;
+    return (
+      (featureValue as number) >= lowerBound &&
+      (featureValue as number) <= upperBound
+    );
+  };
+
+  return makeIntervalComplete(filterValues as FilterInterval[]).some(
+    checkRange
+  );
+}
+
+function filterTime(filterValues: unknown[], featureValue: unknown) {
+  const featureValueAsTimestamp = new Date(featureValue as number).getTime();
+  if (isFinite(featureValueAsTimestamp)) {
+    return filterBetween(filterValues, featureValueAsTimestamp);
+  } else {
+    throw new Error(`Column used to filter by time isn't well formatted.`);
+  }
+}
+
+// FilterTypes.CLOSED_OPEN
+function filterClosedOpen(
+  filterValues: unknown[],
+  featureValue: unknown
+): boolean {
+  const checkRange = (range: [number, number]) => {
+    const [lowerBound, upperBound] = range;
+    return (
+      (featureValue as number) >= lowerBound &&
+      (featureValue as number) < upperBound
+    );
+  };
+
+  return makeIntervalComplete(filterValues as [number, number][]).some(
+    checkRange
+  );
+}
+
+// FilterTypes.STRING_SEARCH
+function filterStringSearch(
+  filterValues: unknown[],
+  featureValue: unknown,
+  params: StringSearchOptions = {}
+): boolean {
+  const normalizedFeatureValue = normalize(featureValue, params);
+  const stringRegExp = params.useRegExp
+    ? filterValues
+    : filterValues.map((filterValue) => {
+        let stringRegExp = escapeRegExp(normalize(filterValue, params));
+
+        if (params.mustStart) stringRegExp = `^${stringRegExp}`;
+        if (params.mustEnd) stringRegExp = `${stringRegExp}$`;
+
+        return stringRegExp;
+      });
+
+  const regex = new RegExp(
+    stringRegExp.join('|'),
+    params.caseSensitive ? 'g' : 'gi'
+  );
+  return !!normalizedFeatureValue.match(regex);
+}
+
+// Aux
+const specialCharRegExp = /[.*+?^${}()|[\]\\]/g;
+const normalizeRegExp = /\p{Diacritic}/gu;
+
+function escapeRegExp(value: string) {
+  return value.replace(specialCharRegExp, '\\$&');
+}
+
+function normalize(data: unknown, params: StringSearchOptions) {
+  let normalizedData = String(data);
+  if (!params.keepSpecialCharacters)
+    normalizedData = normalizedData
+      .normalize('NFD')
+      .replace(normalizeRegExp, '');
+
+  return normalizedData;
+}

package/src/filters/geosjonFeatures.ts

@@ -0,0 +1,32 @@
+import intersects from '@turf/boolean-intersects';
+import {FeatureCollection} from 'geojson';
+import {SpatialFilter} from '..';
+import {FeatureData} from '../types-internal';
+
+export function geojsonFeatures({
+  geojson,
+  spatialFilter,
+  uniqueIdProperty,
+}: {
+  geojson: FeatureCollection;
+  spatialFilter: SpatialFilter;
+  uniqueIdProperty?: string;
+}): FeatureData[] {
+  let uniqueIdx = 0;
+  const map = new Map();
+
+  if (!spatialFilter) {
+    return [];
+  }
+
+  for (const feature of geojson.features) {
+    const uniqueId = uniqueIdProperty
+      ? feature.properties![uniqueIdProperty]
+      : ++uniqueIdx;
+    if (!map.has(uniqueId) && intersects(spatialFilter, feature)) {
+      map.set(uniqueId, feature.properties);
+    }
+  }
+
+  return Array.from(map.values());
+}

package/src/filters/index.ts

@@ -0,0 +1,6 @@
+export * from './Filter.js';
+export * from './FilterTypes.js';
+export * from './geosjonFeatures.js';
+export * from './tileFeatures.js';
+export * from './tileFeaturesGeometries.js';
+export * from './tileFeaturesSpatialIndex.js';

package/src/filters/tileFeatures.ts

@@ -0,0 +1,56 @@
+import {SpatialFilter, SpatialIndexTile, Tile} from '../types';
+import {tileFeaturesGeometries} from './tileFeaturesGeometries';
+import {tileFeaturesSpatialIndex} from './tileFeaturesSpatialIndex';
+import {SpatialIndex, TileFormat} from '../constants';
+import {DEFAULT_GEO_COLUMN} from '../constants-internal';
+import {FeatureData} from '../types-internal';
+import {SpatialDataType} from '../sources/types';
+
+/** @internalRemarks Source: @carto/react-core */
+export type TileFeatures = {
+  tiles: Tile[];
+  tileFormat: TileFormat;
+  spatialDataType: SpatialDataType;
+  spatialDataColumn?: string;
+  spatialFilter?: SpatialFilter;
+  uniqueIdProperty?: string;
+  options?: TileFeatureExtractOptions;
+};
+
+/** @internalRemarks Source: @carto/react-core */
+export type TileFeatureExtractOptions = {
+  storeGeometry?: boolean;
+};
+
+/** @internalRemarks Source: @carto/react-core */
+export function tileFeatures({
+  tiles,
+  spatialFilter,
+  uniqueIdProperty,
+  tileFormat,
+  spatialDataColumn = DEFAULT_GEO_COLUMN,
+  spatialDataType,
+  options = {},
+}: TileFeatures): FeatureData[] {
+  // TODO(cleanup): Is an empty response the expected result when spatialFilter
+  // is omitted? Why not make the parameter required, or return the full input?
+  if (!spatialFilter) {
+    return [];
+  }
+
+  if (spatialDataType !== 'geo') {
+    return tileFeaturesSpatialIndex({
+      tiles: tiles as SpatialIndexTile[],
+      spatialFilter,
+      spatialDataColumn,
+      spatialDataType,
+    });
+  }
+  return tileFeaturesGeometries({
+    tiles,
+    tileFormat,
+    spatialFilter,
+    uniqueIdProperty,
+    options,
+  });
+}