@carto/api-client 0.0.44 → 0.1.1

package/build/api-client.modern.js

@@ -1,3 +1,9 @@
+import bboxClip from '@turf/bbox-clip';
+import bboxPolygon from '@turf/bbox-polygon';
+import union from '@turf/union';
+import { getType } from '@turf/invariant';
+import { featureCollection, feature, polygon, multiPolygon } from '@turf/helpers';
+
 /**
  * @internal
  * @internalRemarks Source: @carto/react-core
@@ -22,21 +28,6 @@ function setClient(c) {
   client = c;
 }
 
-/**
- * Defines a step size increment for use with {@link TimeSeriesRequestOptions}.
- *
- * @internalRemarks Source: @carto/react-core
- */
-var GroupDateType;
-(function (GroupDateType) {
-  GroupDateType["YEARS"] = "year";
-  GroupDateType["MONTHS"] = "month";
-  GroupDateType["WEEKS"] = "week";
-  GroupDateType["DAYS"] = "day";
-  GroupDateType["HOURS"] = "hour";
-  GroupDateType["MINUTES"] = "minute";
-  GroupDateType["SECONDS"] = "second";
-})(GroupDateType || (GroupDateType = {}));
 /**
  * Defines a comparator used when matching a column's values against given filter values.
  *
@@ -221,6 +212,129 @@ function getFilter(filters, {
   return null;
 }
 
+/**
+ * Returns a {@link SpatialFilter} for a given viewport, typically obtained
+ * from deck.gl's `viewport.getBounds()` method ([west, south, east, north]).
+ * If the viewport covers the entire world (to some margin of error in Web
+ * Mercator space), `undefined` is returned instead.
+ *
+ * If the viewport extends beyond longitude range [-180, +180], the polygon
+ * may be reformatted for compatibility with CARTO APIs.
+ */
+function createViewportSpatialFilter(viewport) {
+  if (_isGlobalViewport(viewport)) {
+    return;
+  }
+  return createPolygonSpatialFilter(bboxPolygon(viewport).geometry);
+}
+/**
+ * Returns a {@link SpatialFilter} for a given {@link Polygon} or
+ * {@link MultiPolygon}. If the polygon(s) extend outside longitude
+ * range [-180, +180], the result may be reformatted for compatibility
+ * with CARTO APIs.
+ */
+function createPolygonSpatialFilter(spatialFilter) {
+  return spatialFilter && _normalizeGeometry(spatialFilter) || undefined;
+}
+/**
+ * Check if a viewport is large enough to represent a global coverage.
+ * In this case the spatial filter parameter for widget calculation is removed.
+ *
+ * @internalRemarks Source: @carto/react-core
+ */
+function _isGlobalViewport(viewport) {
+  const [minx, miny, maxx, maxy] = viewport;
+  return maxx - minx > 179.5 * 2 && maxy - miny > 85.05 * 2;
+}
+/**
+ * Normalized a geometry, coming from a mask or a viewport. The parts
+ * spanning outside longitude range [-180, +180] are clipped and "folded"
+ * back to the valid range and unioned to the polygons inide that range.
+ *
+ * It results in a Polygon or MultiPolygon strictly inside the validity range.
+ *
+ * @internalRemarks Source: @carto/react-core
+ */
+function _normalizeGeometry(geometry) {
+  const WORLD = [-180, -90, +180, +90];
+  const worldClip = _clean(bboxClip(geometry, WORLD).geometry);
+  const geometryTxWest = _tx(geometry, 360);
+  const geometryTxEast = _tx(geometry, -360);
+  let result = worldClip;
+  if (result && geometryTxWest) {
+    const worldWestClip = _clean(bboxClip(geometryTxWest, WORLD).geometry);
+    if (worldWestClip) {
+      const collection = featureCollection([feature(result), feature(worldWestClip)]);
+      const merged = union(collection);
+      result = merged ? _clean(merged.geometry) : result;
+    }
+  }
+  if (result && geometryTxEast) {
+    const worldEastClip = _clean(bboxClip(geometryTxEast, WORLD).geometry);
+    if (worldEastClip) {
+      const collection = featureCollection([feature(result), feature(worldEastClip)]);
+      const merged = union(collection);
+      result = merged ? _clean(merged.geometry) : result;
+    }
+  }
+  return result;
+}
+/** @internalRemarks Source: @carto/react-core */
+function _cleanPolygonCoords(cc) {
+  const coords = cc.filter(c => c.length > 0);
+  return coords.length > 0 ? coords : null;
+}
+/** @internalRemarks Source: @carto/react-core */
+function _cleanMultiPolygonCoords(ccc) {
+  const coords = ccc.map(_cleanPolygonCoords).filter(cc => cc);
+  return coords.length > 0 ? coords : null;
+}
+/** @internalRemarks Source: @carto/react-core */
+function _clean(geometry) {
+  if (!geometry) {
+    return null;
+  }
+  if (_isPolygon(geometry)) {
+    const coords = _cleanPolygonCoords(geometry.coordinates);
+    return coords ? polygon(coords).geometry : null;
+  }
+  if (_isMultiPolygon(geometry)) {
+    const coords = _cleanMultiPolygonCoords(geometry.coordinates);
+    return coords ? multiPolygon(coords).geometry : null;
+  }
+  return null;
+}
+/** @internalRemarks Source: @carto/react-core */
+function _txContourCoords(cc, distance) {
+  return cc.map(c => [c[0] + distance, c[1]]);
+}
+/** @internalRemarks Source: @carto/react-core */
+function _txPolygonCoords(ccc, distance) {
+  return ccc.map(cc => _txContourCoords(cc, distance));
+}
+/** @internalRemarks Source: @carto/react-core */
+function _txMultiPolygonCoords(cccc, distance) {
+  return cccc.map(ccc => _txPolygonCoords(ccc, distance));
+}
+/** @internalRemarks Source: @carto/react-core */
+function _tx(geometry, distance) {
+  if (geometry && getType(geometry) === 'Polygon') {
+    const coords = _txPolygonCoords(geometry.coordinates, distance);
+    return polygon(coords).geometry;
+  } else if (geometry && getType(geometry) === 'MultiPolygon') {
+    const coords = _txMultiPolygonCoords(geometry.coordinates, distance);
+    return multiPolygon(coords).geometry;
+  } else {
+    return null;
+  }
+}
+function _isPolygon(geometry) {
+  return getType(geometry) === 'Polygon';
+}
+function _isMultiPolygon(geometry) {
+  return getType(geometry) === 'MultiPolygon';
+}
+
 function _extends() {
   return _extends = Object.assign ? Object.assign.bind() : function (n) {
     for (var e = 1; e < arguments.length; e++) {
@@ -234,7 +348,7 @@ function _objectWithoutPropertiesLoose(r, e) {
   if (null == r) return {};
   var t = {};
   for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
-    if (e.indexOf(n) >= 0) continue;
+    if (e.includes(n)) continue;
     t[n] = r[n];
   }
   return t;
@@ -653,8 +767,8 @@ class WidgetBaseSource {
       columns,
       sortBy,
       sortDirection,
-      page = 0,
-      rowsPerPage = 10
+      offset = 0,
+      limit = 10
     } = params;
     return executeModel({
       model: 'table',
@@ -665,8 +779,8 @@ class WidgetBaseSource {
         column: columns,
         sortBy,
         sortDirection,
-        limit: rowsPerPage,
-        offset: page * rowsPerPage
+        limit,
+        offset
       },
       opts: {
         abortController
@@ -801,14 +915,13 @@ class WidgetTableSource extends WidgetBaseSource {
   }
 }
 
-// loaders.gl
-const isObject = x => x !== null && typeof x === 'object';
-const isPureObject = x => isObject(x) && x.constructor === {}.constructor;
-
 const DEFAULT_TILE_RESOLUTION = 0.5;
 const DEFAULT_AGGREGATION_RES_LEVEL_H3 = 4;
 const DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN = 6;
 
+const isObject = x => x !== null && typeof x === 'object';
+const isPureObject = x => isObject(x) && x.constructor === {}.constructor;
+
 /**
  *
  * Custom error for reported errors in CARTO Maps API.
@@ -816,7 +929,7 @@ const DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN = 6;
  *
  */
 class CartoAPIError extends Error {
-  constructor(error, errorContext, response) {
+  constructor(error, errorContext, response, responseJson) {
     let responseString = 'Failed to connect';
     if (response) {
       responseString = 'Server returned: ';
@@ -842,6 +955,7 @@ class CartoAPIError extends Error {
     super(message);
     this.name = 'CartoAPIError';
     this.response = response;
+    this.responseJson = responseJson;
     this.error = error;
     this.errorContext = errorContext;
   }
@@ -856,15 +970,8 @@ function formatErrorKey(key) {
 const DEFAULT_API_BASE_URL = 'https://gcp-us-east1.api.carto.com';
 const DEFAULT_CLIENT = 'deck-gl-carto';
 const V3_MINOR_VERSION = '3.4';
-const MAX_GET_LENGTH = 8192;
-const DEFAULT_PARAMETERS = {
-  v: V3_MINOR_VERSION,
-  deckglVersion: "0.0.44"
-};
-const DEFAULT_HEADERS = {
-  Accept: 'application/json',
-  'Content-Type': 'application/json'
-};
+// Fastly default limit is 8192; leave some padding.
+const DEFAULT_MAX_LENGTH_URL = 7000;
 
 function joinPath(...args) {
   return args.map(part => part.endsWith('/') ? part.slice(0, -1) : part).join('/');
@@ -881,36 +988,42 @@ function buildSourceUrl({
 }
 
 /**
- * Simple encode parameter
+ * Parameters added to all requests issued with `requestWithParameters()`.
+ * These parameters override parameters already in the base URL, but not
+ * user-provided parameters.
  */
-function encodeParameter(name, value) {
-  if (isPureObject(value) || Array.isArray(value)) {
-    return `${name}=${encodeURIComponent(JSON.stringify(value))}`;
-  }
-  return `${name}=${encodeURIComponent(value)}`;
-}
+const DEFAULT_PARAMETERS = {
+  v: V3_MINOR_VERSION,
+  deckglVersion: "0.1.1"
+};
+const DEFAULT_HEADERS = {
+  Accept: 'application/json',
+  'Content-Type': 'application/json'
+};
 const REQUEST_CACHE = new Map();
 async function requestWithParameters({
   baseUrl,
-  parameters,
-  headers: customHeaders,
-  errorContext
+  parameters = {},
+  headers: customHeaders = {},
+  errorContext,
+  maxLengthURL = DEFAULT_MAX_LENGTH_URL
 }) {
   parameters = {
     ...DEFAULT_PARAMETERS,
     ...parameters
   };
-  const key = createCacheKey(baseUrl, parameters || {}, customHeaders || {});
+  baseUrl = excludeURLParameters(baseUrl, Object.keys(parameters));
+  const key = createCacheKey(baseUrl, parameters, customHeaders);
   if (REQUEST_CACHE.has(key)) {
     return REQUEST_CACHE.get(key);
   }
-  const url = parameters ? createURLWithParameters(baseUrl, parameters) : baseUrl;
+  const url = createURLWithParameters(baseUrl, parameters);
   const headers = {
     ...DEFAULT_HEADERS,
     ...customHeaders
   };
   /* global fetch */
-  const fetchPromise = url.length > MAX_GET_LENGTH ? fetch(baseUrl, {
+  const fetchPromise = url.length > maxLengthURL ? fetch(baseUrl, {
     method: 'POST',
     body: JSON.stringify(parameters),
     headers
@@ -918,17 +1031,19 @@ async function requestWithParameters({
     headers
   });
   let response;
+  let responseJson;
   const jsonPromise = fetchPromise.then(_response => {
     response = _response;
     return response.json();
   }).then(json => {
+    responseJson = json;
     if (!response || !response.ok) {
       throw new Error(json.error);
     }
     return json;
   }).catch(error => {
     REQUEST_CACHE.delete(key);
-    throw new CartoAPIError(error, errorContext, response);
+    throw new CartoAPIError(error, errorContext, response, responseJson);
   });
   REQUEST_CACHE.set(key, jsonPromise);
   return jsonPromise;
@@ -942,9 +1057,33 @@ function createCacheKey(baseUrl, parameters, headers) {
     headers: headerEntries
   });
 }
-function createURLWithParameters(baseUrl, parameters) {
-  const encodedParameters = Object.entries(parameters).map(([key, value]) => encodeParameter(key, value));
-  return `${baseUrl}?${encodedParameters.join('&')}`;
+/**
+ * Appends query string parameters to a URL. Existing URL parameters are kept,
+ * unless there is a conflict, in which case the new parameters override
+ * those already in the URL.
+ */
+function createURLWithParameters(baseUrlString, parameters) {
+  const baseUrl = new URL(baseUrlString);
+  for (const [key, value] of Object.entries(parameters)) {
+    if (isPureObject(value) || Array.isArray(value)) {
+      baseUrl.searchParams.set(key, JSON.stringify(value));
+    } else {
+      baseUrl.searchParams.set(key, value.toString());
+    }
+  }
+  return baseUrl.toString();
+}
+/**
+ * Deletes query string parameters from a URL.
+ */
+function excludeURLParameters(baseUrlString, parameters) {
+  const baseUrl = new URL(baseUrlString);
+  for (const param of parameters) {
+    if (baseUrl.searchParams.has(param)) {
+      baseUrl.searchParams.delete(param);
+    }
+  }
+  return baseUrl.toString();
 }
 
 /* eslint-disable camelcase */
@@ -952,7 +1091,8 @@ const SOURCE_DEFAULTS = {
   apiBaseUrl: DEFAULT_API_BASE_URL,
   clientId: DEFAULT_CLIENT,
   format: 'tilejson',
-  headers: {}
+  headers: {},
+  maxLengthURL: DEFAULT_MAX_LENGTH_URL
 };
 async function baseSource(endpoint, options, urlParameters) {
   const {
@@ -975,6 +1115,7 @@ async function baseSource(endpoint, options, urlParameters) {
   const baseUrl = buildSourceUrl(mergedOptions);
   const {
     clientId,
+    maxLengthURL,
     format
   } = mergedOptions;
   const headers = {
@@ -995,7 +1136,8 @@ async function baseSource(endpoint, options, urlParameters) {
     baseUrl,
     parameters,
     headers,
-    errorContext
+    errorContext,
+    maxLengthURL
   });
   const dataUrl = mapInstantiation[format].url[0];
   if (cache) {
@@ -1006,7 +1148,8 @@ async function baseSource(endpoint, options, urlParameters) {
     const json = await requestWithParameters({
       baseUrl: dataUrl,
       headers,
-      errorContext
+      errorContext,
+      maxLengthURL
     });
     if (accessToken) {
       json.accessToken = accessToken;
@@ -1016,7 +1159,8 @@ async function baseSource(endpoint, options, urlParameters) {
   return await requestWithParameters({
     baseUrl: dataUrl,
     headers,
-    errorContext
+    errorContext,
+    maxLengthURL
   });
 }
 
@@ -1025,13 +1169,11 @@ const boundaryQuerySource = async function (options) {
     columns,
     filters,
     tilesetTableName,
-    matchingColumn = 'id',
     propertiesSqlQuery,
     queryParameters
   } = options;
   const urlParameters = {
     tilesetTableName,
-    matchingColumn,
     propertiesSqlQuery
   };
   if (columns) {
@@ -1051,12 +1193,10 @@ const boundaryTableSource = async function (options) {
     filters,
     tilesetTableName,
     columns,
-    matchingColumn = 'id',
     propertiesTableName
   } = options;
   const urlParameters = {
     tilesetTableName,
-    matchingColumn,
     propertiesTableName
   };
   if (columns) {
@@ -1075,7 +1215,8 @@ const h3QuerySource$1 = async function (options) {
     aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_H3,
     sqlQuery,
     spatialDataColumn = 'h3',
-    queryParameters
+    queryParameters,
+    filters
   } = options;
   const urlParameters = {
     aggregationExp,
@@ -1089,6 +1230,9 @@ const h3QuerySource$1 = async function (options) {
   if (queryParameters) {
     urlParameters.queryParameters = queryParameters;
   }
+  if (filters) {
+    urlParameters.filters = filters;
+  }
   return baseSource('query', options, urlParameters);
 };
 
@@ -1098,7 +1242,8 @@ const h3TableSource$1 = async function (options) {
     aggregationExp,
     aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_H3,
     spatialDataColumn = 'h3',
-    tableName
+    tableName,
+    filters
   } = options;
   const urlParameters = {
     aggregationExp,
@@ -1109,6 +1254,9 @@ const h3TableSource$1 = async function (options) {
   if (aggregationResLevel) {
     urlParameters.aggregationResLevel = String(aggregationResLevel);
   }
+  if (filters) {
+    urlParameters.filters = filters;
+  }
   return baseSource('table', options, urlParameters);
 };
 
@@ -1124,11 +1272,15 @@ const h3TilesetSource = async function (options) {
 
 const rasterSource = async function (options) {
   const {
-    tableName
+    tableName,
+    filters
   } = options;
   const urlParameters = {
     name: tableName
   };
+  if (filters) {
+    urlParameters.filters = filters;
+  }
   return baseSource('raster', options, urlParameters);
 };
 
@@ -1139,7 +1291,8 @@ const quadbinQuerySource$1 = async function (options) {
     aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN,
     sqlQuery,
     spatialDataColumn = 'quadbin',
-    queryParameters
+    queryParameters,
+    filters
   } = options;
   const urlParameters = {
     aggregationExp,
@@ -1153,6 +1306,9 @@ const quadbinQuerySource$1 = async function (options) {
   if (queryParameters) {
     urlParameters.queryParameters = queryParameters;
   }
+  if (filters) {
+    urlParameters.filters = filters;
+  }
   return baseSource('query', options, urlParameters);
 };
 
@@ -1162,7 +1318,8 @@ const quadbinTableSource$1 = async function (options) {
     aggregationExp,
     aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN,
     spatialDataColumn = 'quadbin',
-    tableName
+    tableName,
+    filters
   } = options;
   const urlParameters = {
     aggregationExp,
@@ -1173,6 +1330,9 @@ const quadbinTableSource$1 = async function (options) {
   if (aggregationResLevel) {
     urlParameters.aggregationResLevel = String(aggregationResLevel);
   }
+  if (filters) {
+    urlParameters.filters = filters;
+  }
   return baseSource('table', options, urlParameters);
 };
 
@@ -1320,5 +1480,5 @@ function assignDefaultProps(props) {
   }
 }
 
-export { FilterType, GroupDateType, WidgetBaseSource, WidgetQuerySource, WidgetTableSource, addFilter, clearFilters, getClient, getFilter, h3QuerySource, h3TableSource, hasFilter, quadbinQuerySource, quadbinTableSource, removeFilter, setClient, vectorQuerySource, vectorTableSource };
+export { FilterType, WidgetBaseSource, WidgetQuerySource, WidgetTableSource, addFilter, clearFilters, createPolygonSpatialFilter, createViewportSpatialFilter, getClient, getFilter, h3QuerySource, h3TableSource, hasFilter, quadbinQuerySource, quadbinTableSource, removeFilter, setClient, vectorQuerySource, vectorTableSource };
 //# sourceMappingURL=api-client.modern.js.map