@carto/api-client 0.4.6-0 → 0.4.6

package/src/operations/aggregation.ts

@@ -1,154 +0,0 @@
-import {AggregationType} from '../types';
-import {FeatureData} from '../types-internal';
-
-/** @internalRemarks Source: @carto/react-core */
-export type AggregationFunction = (
-  values: unknown[] | FeatureData[],
-  keys?: string[] | string,
-  joinOperation?: AggregationType
-) => number;
-
-/** @internalRemarks Source: @carto/react-core */
-export const aggregationFunctions: Record<
-  Exclude<AggregationType, 'custom'>,
-  AggregationFunction
-> = {
-  count: (values) => values.length,
-  min: (...args) => applyAggregationFunction(min, ...args),
-  max: (...args) => applyAggregationFunction(max, ...args),
-  sum: (...args) => applyAggregationFunction(sum, ...args),
-  avg: (...args) => applyAggregationFunction(avg, ...args),
-};
-
-/** @internalRemarks Source: @carto/react-core */
-export function aggregate(
-  feature: FeatureData,
-  keys?: string[],
-  operation?: AggregationType
-): unknown {
-  if (!keys?.length) {
-    throw new Error('Cannot aggregate a feature without having keys');
-  } else if (keys.length === 1) {
-    const value = feature[keys[0]];
-    return isPotentiallyValidNumber(value) ? Number(value) : value;
-  }
-
-  const aggregationFn =
-    aggregationFunctions[operation as Exclude<AggregationType, 'custom'>];
-
-  if (!aggregationFn) {
-    throw new Error(`${operation} isn't a valid aggregation function`);
-  }
-
-  return aggregationFn(
-    keys.map((column) => {
-      const value = feature[column];
-      return isPotentiallyValidNumber(value) ? Number(value) : value;
-    })
-  );
-}
-
-/*
- * Forced casting to Number (just of non empty strings) allows to work-around
- * some specific situations, where a big numeric field is transformed into a string when generating the tileset(eg.PG)
- */
-function isPotentiallyValidNumber(value: unknown): boolean {
-  return typeof value === 'string' && value.trim().length > 0;
-}
-
-const applyAggregationFunction = (
-  aggFn: AggregationFunction,
-  values: unknown[] | FeatureData[],
-  keys?: string[] | string,
-  operation?: AggregationType
-) => {
-  const normalizedKeys = normalizeKeys(keys);
-  const elements =
-    (normalizedKeys?.length || 0) <= 1
-      ? filterFalsyElements(values as unknown[], normalizedKeys || [])
-      : values;
-  return aggFn(elements, keys, operation);
-};
-
-function filterFalsyElements(
-  values: unknown[] | FeatureData[],
-  keys: string[]
-) {
-  const filterFn = (value: unknown) => value !== null && value !== undefined;
-
-  if (!keys?.length) {
-    return values.filter(filterFn);
-  }
-
-  return (values as FeatureData[]).filter((v) => filterFn(v[keys[0]]));
-}
-
-// Aggregation functions
-function avg(
-  values: unknown[] | FeatureData[],
-  keys?: string[] | string,
-  joinOperation?: AggregationType
-): number {
-  return sum(values, keys, joinOperation) / (values.length || 1);
-}
-
-function sum(
-  values: unknown[] | FeatureData[],
-  keys?: string[] | string,
-  joinOperation?: AggregationType
-): number {
-  const normalizedKeys = normalizeKeys(keys);
-
-  if (normalizedKeys) {
-    return (values as FeatureData[]).reduce(
-      (a, b) => a + (aggregate(b, normalizedKeys, joinOperation) as number),
-      0
-    );
-  }
-
-  return values.reduce((a: number, b: unknown) => a + (b as number), 0);
-}
-
-function min(
-  values: unknown[] | FeatureData[],
-  keys?: string[] | string,
-  joinOperation?: AggregationType
-): number {
-  const normalizedKeys = normalizeKeys(keys);
-  if (normalizedKeys) {
-    return (values as FeatureData[]).reduce(
-      (a, b) =>
-        Math.min(a, aggregate(b, normalizedKeys, joinOperation) as number),
-      Infinity
-    );
-  }
-  return Math.min(...(values as number[]));
-}
-
-function max(
-  values: unknown[] | FeatureData[],
-  keys?: string[] | string,
-  joinOperation?: AggregationType
-): number {
-  const normalizedKeys = normalizeKeys(keys);
-  if (normalizedKeys) {
-    return (values as FeatureData[]).reduce(
-      (a, b) =>
-        Math.max(a, aggregate(b, normalizedKeys, joinOperation) as number),
-      -Infinity
-    );
-  }
-  return Math.max(...(values as number[]));
-}
-
-// Aux
-
-// Keys can come as a string (one column) or a strings array (multiple column)
-// Use always an array to make the code easier
-function normalizeKeys(keys: unknown): string[] | undefined {
-  return Array.isArray(keys)
-    ? keys
-    : typeof keys === 'string'
-      ? [keys]
-      : undefined;
-}

package/src/operations/applySorting.ts

@@ -1,109 +0,0 @@
-import {firstBy} from 'thenby';
-import {SortDirection} from '../types';
-import {FeatureData} from '../types-internal';
-
-// TODO(cleanup): Could this be simplified?
-type SortColumns = string | string[] | object[];
-
-interface SortOptions {
-  sortBy?: SortColumns;
-  sortByDirection?: SortDirection;
-  sortByColumnType?: 'number' | 'string' | 'date';
-}
-
-/**
- * Apply sort structure to a collection of features
- * @param features
- * @param [sortOptions]
- * @param [sortOptions.sortBy] - One or more columns to sort by
- * @param [sortOptions.sortByDirection] - Direction by the columns will be sorted
- * @param [sortOptions.sortByColumnType] - Column type
- * @internal
- * @internalRemarks Source: @carto/react-core
- */
-export function applySorting(
-  features: FeatureData[],
-  {
-    sortBy,
-    sortByDirection = 'asc',
-    sortByColumnType = 'string',
-  }: SortOptions = {}
-): FeatureData[] {
-  // If sortBy is undefined, pass all features
-  if (sortBy === undefined) {
-    return features;
-  }
-
-  // sortOptions exists, but are bad formatted
-  const isValidSortBy =
-    (Array.isArray(sortBy) && sortBy.length) || // sortBy can be an array of columns
-    typeof sortBy === 'string'; // or just one column
-
-  if (!isValidSortBy) {
-    throw new Error('Sorting options are bad formatted');
-  }
-  const sortFn = createSortFn({
-    sortBy,
-    sortByDirection,
-    sortByColumnType: sortByColumnType || 'string',
-  });
-  return features.sort(sortFn);
-}
-
-// Aux
-function createSortFn({
-  sortBy,
-  sortByDirection,
-  sortByColumnType,
-}: Required<SortOptions>) {
-  const [firstSortOption, ...othersSortOptions] = normalizeSortByOptions({
-    sortBy,
-    sortByDirection,
-    sortByColumnType,
-  }) as Parameters<typeof firstBy>[];
-
-  let sortFn = firstBy(...firstSortOption);
-  for (let sortOptions of othersSortOptions) {
-    sortFn = sortFn.thenBy(...sortOptions);
-  }
-
-  return sortFn;
-}
-
-function normalizeSortByOptions({
-  sortBy,
-  sortByDirection,
-  sortByColumnType,
-}: Required<SortOptions>) {
-  const numberFormat = sortByColumnType === 'number' && {
-    cmp: (a: number, b: number) => a - b,
-  };
-  if (!Array.isArray(sortBy)) {
-    sortBy = [sortBy];
-  }
-  return sortBy.map((sortByEl) => {
-    // sortByEl is 'column'
-    if (typeof sortByEl === 'string') {
-      return [sortByEl, {direction: sortByDirection, ...numberFormat}];
-    }
-
-    if (Array.isArray(sortByEl)) {
-      // sortBy is ['column']
-      if (sortByEl[1] === undefined) {
-        return [sortByEl, {direction: sortByDirection, ...numberFormat}];
-      }
-
-      // sortBy is ['column', { ... }]
-      if (typeof sortByEl[1] === 'object') {
-        const othersSortOptions = numberFormat
-          ? {...numberFormat, ...sortByEl[1]}
-          : sortByEl[1];
-        return [
-          sortByEl[0],
-          {direction: sortByDirection, ...othersSortOptions},
-        ];
-      }
-    }
-    return sortByEl;
-  });
-}

package/src/operations/groupBy.ts

@@ -1,59 +0,0 @@
-import {aggregationFunctions, aggregate} from './aggregation.js';
-import {AggregationType} from '../types';
-import {FeatureData} from '../types-internal';
-
-/** @internalRemarks Source: @carto/react-core */
-export type GroupByFeature = {
-  name: string;
-  value: number;
-}[];
-
-/** @internalRemarks Source: @carto/react-core */
-export function groupValuesByColumn({
-  data,
-  valuesColumns,
-  joinOperation,
-  keysColumn,
-  operation,
-}: {
-  data: FeatureData[];
-  valuesColumns?: string[];
-  joinOperation?: AggregationType;
-  keysColumn: string;
-  operation: AggregationType;
-}): GroupByFeature | null {
-  if (Array.isArray(data) && data.length === 0) {
-    return null;
-  }
-  const groups = data.reduce((accumulator, item) => {
-    const group = item[keysColumn];
-
-    const values = accumulator.get(group) || [];
-    accumulator.set(group, values);
-
-    const aggregatedValue = aggregate(item, valuesColumns, joinOperation);
-
-    const isValid =
-      (operation === 'count' ? true : aggregatedValue !== null) &&
-      aggregatedValue !== undefined;
-
-    if (isValid) {
-      values.push(aggregatedValue);
-      accumulator.set(group, values);
-    }
-
-    return accumulator;
-  }, new Map()); // We use a map to be able to maintain the type in the key value
-
-  const targetOperation =
-    aggregationFunctions[operation as Exclude<AggregationType, 'custom'>];
-
-  if (targetOperation) {
-    return Array.from(groups).map(([name, value]) => ({
-      name,
-      value: targetOperation(value),
-    }));
-  }
-
-  return [];
-}

package/src/operations/groupByDate.ts

@@ -1,98 +0,0 @@
-import {AggregationType, GroupDateType} from '../types.js';
-import {getUTCMonday} from '../utils/dateUtils.js';
-import {aggregate, aggregationFunctions} from './aggregation.js';
-import {GroupByFeature} from './groupBy.js';
-
-const GROUP_KEY_FN_MAPPING: Record<GroupDateType, (date: Date) => number> = {
-  year: (date: Date) => Date.UTC(date.getUTCFullYear()),
-  month: (date: Date) => Date.UTC(date.getUTCFullYear(), date.getUTCMonth()),
-  week: (date: Date) => getUTCMonday(date),
-  day: (date: Date) =>
-    Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()),
-  hour: (date: Date) =>
-    Date.UTC(
-      date.getUTCFullYear(),
-      date.getUTCMonth(),
-      date.getUTCDate(),
-      date.getUTCHours()
-    ),
-  minute: (date: Date) =>
-    Date.UTC(
-      date.getUTCFullYear(),
-      date.getUTCMonth(),
-      date.getUTCDate(),
-      date.getUTCHours(),
-      date.getUTCMinutes()
-    ),
-  second: (date: Date) =>
-    Date.UTC(
-      date.getUTCFullYear(),
-      date.getUTCMonth(),
-      date.getUTCDate(),
-      date.getUTCHours(),
-      date.getUTCMinutes(),
-      date.getUTCSeconds()
-    ),
-};
-
-/** @internalRemarks Source: @carto/react-core */
-export function groupValuesByDateColumn({
-  data,
-  valuesColumns,
-  joinOperation,
-  keysColumn,
-  groupType,
-  operation,
-}: {
-  data: Record<string, unknown>[];
-  valuesColumns?: string[];
-  joinOperation?: Exclude<AggregationType, 'custom'>;
-  keysColumn: string;
-  groupType: GroupDateType;
-  operation?: Exclude<AggregationType, 'custom'>;
-}): GroupByFeature | null {
-  if (Array.isArray(data) && data.length === 0) {
-    return null;
-  }
-
-  const groupKeyFn = GROUP_KEY_FN_MAPPING[groupType];
-
-  if (!groupKeyFn) {
-    return null;
-  }
-
-  const groups = data.reduce((acc, item) => {
-    const value = item[keysColumn];
-    const formattedValue = new Date(value as number);
-    const groupKey = groupKeyFn(formattedValue);
-
-    if (!isNaN(groupKey)) {
-      let groupedValues = acc.get(groupKey);
-      if (!groupedValues) {
-        groupedValues = [];
-        acc.set(groupKey, groupedValues);
-      }
-
-      const aggregatedValue = aggregate(item, valuesColumns, joinOperation);
-
-      const isValid = aggregatedValue !== null && aggregatedValue !== undefined;
-
-      if (isValid) {
-        groupedValues.push(aggregatedValue);
-        acc.set(groupKey, groupedValues);
-      }
-    }
-
-    return acc;
-  }, new Map());
-
-  const targetOperation =
-    aggregationFunctions[operation as Exclude<AggregationType, 'custom'>];
-
-  return [...groups.entries()]
-    .map(([name, value]) => ({
-      name,
-      value: targetOperation(value),
-    }))
-    .sort((a, b) => a.name - b.name);
-}

package/src/operations/histogram.ts

@@ -1,66 +0,0 @@
-import {aggregate, aggregationFunctions} from './aggregation';
-import {AggregationType} from '../types';
-import {FeatureData} from '../types-internal';
-
-/**
- * Histogram computation.
- * @internalRemarks Source: @carto/react-core
- */
-export function histogram({
-  data,
-  valuesColumns,
-  joinOperation,
-  ticks,
-  operation,
-}: {
-  data: FeatureData[];
-  valuesColumns?: string[];
-  joinOperation?: Exclude<AggregationType, 'custom'>;
-  ticks: number[];
-  operation: Exclude<AggregationType, 'custom'>;
-}): number[] {
-  if (Array.isArray(data) && data.length === 0) {
-    return [];
-  }
-
-  const binsContainer = [Number.MIN_SAFE_INTEGER, ...ticks].map(
-    (tick, index, arr) => ({
-      bin: index,
-      start: tick,
-      end: index === arr.length - 1 ? Number.MAX_SAFE_INTEGER : arr[index + 1],
-      values: [] as number[],
-    })
-  );
-
-  data.forEach((feature) => {
-    const featureValue = aggregate(
-      feature,
-      valuesColumns,
-      joinOperation
-    ) as number;
-
-    const isValid = featureValue !== null && featureValue !== undefined;
-
-    if (!isValid) {
-      return;
-    }
-
-    const binContainer = binsContainer.find(
-      (bin) => bin.start <= featureValue && bin.end > featureValue
-    );
-
-    if (!binContainer) {
-      return;
-    }
-
-    binContainer.values.push(featureValue);
-  });
-
-  const targetOperation = aggregationFunctions[operation];
-  const transformedBins = binsContainer.map(
-    (binContainer) => binContainer.values
-  );
-  return transformedBins.map((values) =>
-    values.length ? targetOperation(values) : 0
-  );
-}

package/src/operations/index.ts

@@ -1,6 +0,0 @@
-export * from './aggregation.js';
-export * from './applySorting.js';
-export * from './groupBy.js';
-export * from './groupByDate.js';
-export * from './histogram.js';
-export * from './scatterPlot.js';

package/src/operations/scatterPlot.ts

@@ -1,50 +0,0 @@
-import {aggregate} from './aggregation';
-import {FeatureData} from '../types-internal';
-import {AggregationType} from '../types';
-
-export type ScatterPlotFeature = [number, number][];
-
-/**
- * Filters invalid features and formats  data.
- * @internalRemarks Source: @carto/react-core
- */
-export function scatterPlot({
-  data,
-  xAxisColumns,
-  xAxisJoinOperation,
-  yAxisColumns,
-  yAxisJoinOperation,
-}: {
-  data: FeatureData[];
-  xAxisColumns: string[];
-  xAxisJoinOperation?: AggregationType;
-  yAxisColumns: string[];
-  yAxisJoinOperation?: AggregationType;
-}): ScatterPlotFeature {
-  return data.reduce(
-    (acc, feature) => {
-      const xValue = aggregate(
-        feature,
-        xAxisColumns,
-        xAxisJoinOperation
-      ) as number;
-
-      const xIsValid = xValue !== null && xValue !== undefined;
-
-      const yValue = aggregate(
-        feature,
-        yAxisColumns,
-        yAxisJoinOperation
-      ) as number;
-
-      const yIsValid = yValue !== null && yValue !== undefined;
-
-      if (xIsValid && yIsValid) {
-        acc.push([xValue, yValue]);
-      }
-
-      return acc;
-    },
-    [] as [number, number][]
-  );
-}

package/src/utils/dateUtils.ts

@@ -1,28 +0,0 @@
-/**
- * Returns midnight (local time) on the Monday preceeding a given date, in
- * milliseconds since the UNIX epoch.
- */
-export function getMonday(date: number | Date): number {
-  const dateCp = new Date(date);
-  const day = dateCp.getDay();
-  const diff = dateCp.getDate() - day + (day ? 1 : -6); // adjust when day is sunday
-  dateCp.setDate(diff);
-  dateCp.setHours(0, 0, 0, 0);
-  return dateCp.getTime();
-}
-
-/**
- * Returns midnight (UTC) on the Monday preceeding a given date, in
- * milliseconds since the UNIX epoch.
- */
-export function getUTCMonday(date: number | Date): number {
-  const dateCp = new Date(date);
-  const day = dateCp.getUTCDay();
-  const diff = dateCp.getUTCDate() - day + (day ? 1 : -6); // adjust when day is sunday
-  dateCp.setUTCDate(diff);
-  return Date.UTC(
-    dateCp.getUTCFullYear(),
-    dateCp.getUTCMonth(),
-    dateCp.getUTCDate()
-  );
-}

package/src/utils/getTileFormat.ts

@@ -1,9 +0,0 @@
-import {TileFormat} from '../constants.js';
-import {Tilejson} from '../sources/types.js';
-
-export function getTileFormat(tilejson: Tilejson): TileFormat {
-  const tileParams = new URL(tilejson.tiles[0]).searchParams;
-  return tileParams.get('formatTiles') === 'mvt'
-    ? TileFormat.MVT
-    : TileFormat.BINARY;
-}

package/src/utils/makeIntervalComplete.ts

@@ -1,17 +0,0 @@
-import {FilterInterval, FilterIntervalComplete} from '../types';
-
-export function makeIntervalComplete(
-  intervals: FilterInterval[]
-): FilterIntervalComplete[] {
-  return intervals.map((val) => {
-    if (val[0] === undefined || val[0] === null) {
-      return [Number.MIN_SAFE_INTEGER, val[1]];
-    }
-
-    if (val[1] === undefined || val[1] === null) {
-      return [val[0], Number.MAX_SAFE_INTEGER];
-    }
-
-    return val;
-  }) as FilterIntervalComplete[];
-}

package/src/utils/transformTileCoordsToWGS84.ts

@@ -1,77 +0,0 @@
-import {lerp} from '@math.gl/core';
-import {lngLatToWorld, worldToLngLat} from '@math.gl/web-mercator';
-import {BBox, GeoJsonGeometryTypes, Geometry, Position} from 'geojson';
-
-type TransformFn = (coordinates: any[], bbox: Position[]) => any[];
-
-const TRANSFORM_FN: Record<
-  Exclude<GeoJsonGeometryTypes, 'GeometryCollection'>,
-  TransformFn
-> = {
-  Point: transformPoint,
-  MultiPoint: transformMultiPoint,
-  LineString: transformLineString,
-  MultiLineString: transformMultiLineString,
-  Polygon: transformPolygon,
-  MultiPolygon: transformMultiPolygon,
-};
-
-/**
- * Transform tile coords to WGS84 coordinates.
- *
- * @param geometry - any valid geojson geometry
- * @param bbox - geojson bbox
- */
-export function transformTileCoordsToWGS84<T extends Geometry>(
-  geometry: T,
-  bbox: BBox
-): T {
-  const [west, south, east, north] = bbox;
-  const nw = lngLatToWorld([west, north]);
-  const se = lngLatToWorld([east, south]);
-  const projectedBbox = [nw, se];
-
-  if (geometry.type === 'GeometryCollection') {
-    throw new Error('Unsupported geometry type GeometryCollection');
-  }
-
-  const transformFn = TRANSFORM_FN[geometry.type];
-  const coordinates = transformFn(geometry.coordinates, projectedBbox);
-  return {...geometry, coordinates};
-}
-
-function transformPoint([pointX, pointY]: Position, [nw, se]: Position[]) {
-  const x = lerp(nw[0], se[0], pointX);
-  const y = lerp(nw[1], se[1], pointY);
-
-  return worldToLngLat([x, y]);
-}
-
-function getPoints(geometry: Position[], bbox: Position[]) {
-  return geometry.map((g) => transformPoint(g, bbox));
-}
-
-function transformMultiPoint(multiPoint: Position[], bbox: Position[]) {
-  return getPoints(multiPoint, bbox);
-}
-
-function transformLineString(line: Position[], bbox: Position[]) {
-  return getPoints(line, bbox);
-}
-
-function transformMultiLineString(
-  multiLineString: Position[][],
-  bbox: Position[]
-) {
-  return multiLineString.map((lineString) =>
-    transformLineString(lineString, bbox)
-  );
-}
-
-function transformPolygon(polygon: Position[][], bbox: Position[]) {
-  return polygon.map((polygonRing) => getPoints(polygonRing, bbox));
-}
-
-function transformMultiPolygon(multiPolygon: Position[][][], bbox: Position[]) {
-  return multiPolygon.map((polygon) => transformPolygon(polygon, bbox));
-}