@carto/api-client 0.0.1-0

package/build/api-client.modern.js

@@ -0,0 +1,1089 @@
+const CLIENT_ID = 'carto-api-client';
+/** @internalRemarks Source: @carto/constants */
+var MapType;
+(function (MapType) {
+  MapType["TABLE"] = "table";
+  MapType["QUERY"] = "query";
+  MapType["TILESET"] = "tileset";
+})(MapType || (MapType = {}));
+/** @internalRemarks Source: @carto/constants */
+var ApiVersion;
+(function (ApiVersion) {
+  ApiVersion["V1"] = "v1";
+  ApiVersion["V2"] = "v2";
+  ApiVersion["V3"] = "v3";
+})(ApiVersion || (ApiVersion = {}));
+/** @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 = {}));
+/** @internalRemarks Source: @carto/react-api, @deck.gl/carto */
+var FilterType;
+(function (FilterType) {
+  FilterType["IN"] = "in";
+  /** [a, b] both are included. */
+  FilterType["BETWEEN"] = "between";
+  /** [a, b) a is included, b is not. */
+  FilterType["CLOSED_OPEN"] = "closed_open";
+  FilterType["TIME"] = "time";
+  FilterType["STRING_SEARCH"] = "stringSearch";
+})(FilterType || (FilterType = {}));
+
+/**
+ * Default client
+ * @internalRemarks Source: @carto/react-core
+ */
+let client = CLIENT_ID;
+/** @internalRemarks Source: @carto/react-core */
+function getClient() {
+  return client;
+}
+/** @internalRemarks Source: @carto/react-core */
+function setClient(c) {
+  client = c;
+}
+
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function (n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+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;
+    t[n] = r[n];
+  }
+  return t;
+}
+
+/**
+ * Threshold to use GET requests, vs POST
+ * @internalRemarks Source: @carto/constants
+ * @internal
+ */
+const REQUEST_GET_MAX_URL_LENGTH = 2048;
+/**
+ * @internalRemarks Source: @carto/constants
+ * @internal
+ */
+const DEFAULT_API_BASE_URL$1 = 'https://gcp-us-east1.api.carto.com';
+/**
+ * @internalRemarks Source: @carto/react-api
+ * @internal
+ */
+const DEFAULT_GEO_COLUMN = 'geom';
+
+const FILTER_TYPES = new Set(Object.values(FilterType));
+const isFilterType = type => FILTER_TYPES.has(type);
+/**
+ * @privateRemarks Source: @carto/react-widgets
+ * @internal
+ */
+function getApplicableFilters(owner, filters) {
+  if (!filters) return {};
+  const applicableFilters = {};
+  for (const column in filters) {
+    for (const type in filters[column]) {
+      if (!isFilterType(type)) continue;
+      const filter = filters[column][type];
+      if (filter && filter.owner !== owner) {
+        applicableFilters[column] || (applicableFilters[column] = {});
+        applicableFilters[column][type] = filter;
+      }
+    }
+  }
+  return applicableFilters;
+}
+/**
+ * Due to each data warehouse having its own behavior with columns,
+ * we need to normalize them and transform every key to lowercase.
+ *
+ * @internalRemarks Source: @carto/react-widgets
+ * @internal
+ */
+function normalizeObjectKeys(el) {
+  if (Array.isArray(el)) {
+    return el.map(value => normalizeObjectKeys(value));
+  } else if (typeof el !== 'object') {
+    return el;
+  }
+  return Object.entries(el).reduce((acc, [key, value]) => {
+    acc[key.toLowerCase()] = typeof value === 'object' && value ? normalizeObjectKeys(value) : value;
+    return acc;
+  }, {});
+}
+/** @internalRemarks Source: @carto/react-core */
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+/**
+ * @internalRemarks Source: @carto/react-core
+ * @internal
+ */
+class InvalidColumnError extends Error {
+  constructor(message) {
+    super(`${InvalidColumnError.NAME}: ${message}`);
+    this.name = InvalidColumnError.NAME;
+  }
+  static is(error) {
+    var _error$message;
+    return error instanceof InvalidColumnError || ((_error$message = error.message) == null ? void 0 : _error$message.includes(InvalidColumnError.NAME));
+  }
+}
+InvalidColumnError.NAME = 'InvalidColumnError';
+
+/**
+ * Return more descriptive error from API
+ * @internalRemarks Source: @carto/react-api
+ */
+function dealWithApiError({
+  response,
+  data
+}) {
+  var _data$error, _data$error2;
+  if (data.error === 'Column not found') {
+    throw new InvalidColumnError(`${data.error} ${data.column_name}`);
+  }
+  if ((_data$error = data.error) != null && _data$error.includes('Missing columns')) {
+    throw new InvalidColumnError(data.error);
+  }
+  switch (response.status) {
+    case 401:
+      throw new Error('Unauthorized access. Invalid credentials');
+    case 403:
+      throw new Error('Forbidden access to the requested data');
+    default:
+      const msg = data && data.error && typeof data.error === 'string' ? data.error : JSON.stringify((data == null ? void 0 : data.hint) || ((_data$error2 = data.error) == null ? void 0 : _data$error2[0]));
+      throw new Error(msg);
+  }
+}
+/** @internalRemarks Source: @carto/react-api */
+function checkCredentials(credentials) {
+  if (!credentials || !credentials.apiBaseUrl || !credentials.accessToken) {
+    throw new Error('Missing or bad credentials provided');
+  }
+}
+/** @internalRemarks Source: @carto/react-api */
+async function makeCall({
+  url,
+  credentials,
+  opts
+}) {
+  let response;
+  let data;
+  const isPost = (opts == null ? void 0 : opts.method) === 'POST';
+  try {
+    var _opts$abortController;
+    response = await fetch(url.toString(), _extends({
+      headers: _extends({
+        Authorization: `Bearer ${credentials.accessToken}`
+      }, isPost ? {
+        'Content-Type': 'application/json'
+      } : {})
+    }, isPost ? {
+      method: opts == null ? void 0 : opts.method,
+      body: opts == null ? void 0 : opts.body
+    } : {}, {
+      signal: opts == null || (_opts$abortController = opts.abortController) == null ? void 0 : _opts$abortController.signal
+    }, opts == null ? void 0 : opts.otherOptions));
+    data = await response.json();
+  } catch (error) {
+    if (error.name === 'AbortError') throw error;
+    throw new Error(`Failed request: ${error}`);
+  }
+  if (!response.ok) {
+    dealWithApiError({
+      response,
+      data
+    });
+  }
+  return data;
+}
+
+/** @internalRemarks Source: @carto/react-api */
+const AVAILABLE_MODELS = ['category', 'histogram', 'formula', 'timeseries', 'range', 'scatterplot', 'table'];
+/**
+ * Execute a SQL model request.
+ * @internalRemarks Source: @carto/react-api
+ */
+function executeModel(props) {
+  assert(props.source, 'executeModel: missing source');
+  assert(props.model, 'executeModel: missing model');
+  assert(props.params, 'executeModel: missing params');
+  assert(AVAILABLE_MODELS.indexOf(props.model) !== -1, `executeModel: model provided isn't valid. Available models: ${AVAILABLE_MODELS.join(', ')}`);
+  const {
+    source,
+    model,
+    params,
+    spatialFilter,
+    opts
+  } = props;
+  checkCredentials(source.credentials);
+  assert(source.credentials.apiVersion === ApiVersion.V3, 'SQL Model API is a feature only available in CARTO 3.');
+  assert(source.type !== MapType.TILESET, 'executeModel: Tileset not supported');
+  let url = `${source.credentials.apiBaseUrl}/v3/sql/${source.connection}/model/${model}`;
+  const {
+    filters,
+    filtersLogicalOperator = 'and',
+    data,
+    type
+  } = source;
+  const queryParameters = source.queryParameters ? JSON.stringify(source.queryParameters) : '';
+  const queryParams = {
+    type,
+    client: getClient(),
+    source: data,
+    params: JSON.stringify(params),
+    queryParameters,
+    filters: JSON.stringify(filters),
+    filtersLogicalOperator
+  };
+  // API supports multiple filters, we apply it only to geoColumn
+  const spatialFilters = spatialFilter ? {
+    [source.geoColumn ? source.geoColumn : DEFAULT_GEO_COLUMN]: spatialFilter
+  } : undefined;
+  if (spatialFilters) {
+    queryParams.spatialFilters = JSON.stringify(spatialFilters);
+  }
+  const urlWithSearchParams = url + '?' + new URLSearchParams(queryParams).toString();
+  const isGet = urlWithSearchParams.length <= REQUEST_GET_MAX_URL_LENGTH;
+  if (isGet) {
+    url = urlWithSearchParams;
+  } else {
+    // undo the JSON.stringify, @TODO find a better pattern
+    queryParams.params = params;
+    queryParams.filters = filters;
+    queryParams.queryParameters = source.queryParameters;
+    if (spatialFilters) {
+      queryParams.spatialFilters = spatialFilters;
+    }
+  }
+  return makeCall({
+    url,
+    credentials: source.credentials,
+    opts: _extends({}, opts, {
+      method: isGet ? 'GET' : 'POST'
+    }, !isGet && {
+      body: JSON.stringify(queryParams)
+    })
+  });
+}
+
+const _excluded = ["filterOwner", "spatialFilter", "abortController", "operationExp"],
+  _excluded2 = ["filterOwner", "spatialFilter", "abortController"],
+  _excluded3 = ["filterOwner", "spatialFilter", "abortController"],
+  _excluded4 = ["filterOwner", "spatialFilter", "abortController"],
+  _excluded5 = ["filterOwner", "spatialFilter", "abortController"],
+  _excluded6 = ["filterOwner", "abortController", "spatialFilter"],
+  _excluded7 = ["filterOwner", "spatialFilter", "abortController"];
+class WidgetBaseSource {
+  constructor(props) {
+    this.props = void 0;
+    this.credentials = void 0;
+    this.connectionName = void 0;
+    this.props = _extends({}, WidgetBaseSource.defaultProps, props);
+    this.connectionName = props.connectionName;
+    this.credentials = {
+      apiVersion: props.apiVersion || ApiVersion.V3,
+      apiBaseUrl: props.apiBaseUrl || DEFAULT_API_BASE_URL$1,
+      clientId: props.clientId || getClient(),
+      accessToken: props.accessToken,
+      geoColumn: props.geoColumn || DEFAULT_GEO_COLUMN
+    };
+  }
+  getSource(owner) {
+    return _extends({}, this.props, {
+      credentials: this.credentials,
+      connection: this.connectionName,
+      filters: getApplicableFilters(owner, this.props.filters)
+    });
+  }
+  async getFormula(props) {
+    const {
+        filterOwner,
+        spatialFilter,
+        abortController,
+        operationExp
+      } = props,
+      params = _objectWithoutPropertiesLoose(props, _excluded);
+    const {
+      column,
+      operation
+    } = params;
+    return executeModel({
+      model: 'formula',
+      source: this.getSource(filterOwner),
+      spatialFilter,
+      params: {
+        column: column != null ? column : '*',
+        operation,
+        operationExp
+      },
+      opts: {
+        abortController
+      }
+    }).then(res => normalizeObjectKeys(res.rows[0]));
+  }
+  async getCategories(props) {
+    const {
+        filterOwner,
+        spatialFilter,
+        abortController
+      } = props,
+      params = _objectWithoutPropertiesLoose(props, _excluded2);
+    const {
+      column,
+      operation,
+      operationColumn
+    } = params;
+    return executeModel({
+      model: 'category',
+      source: this.getSource(filterOwner),
+      spatialFilter,
+      params: {
+        column,
+        operation,
+        operationColumn: operationColumn || column
+      },
+      opts: {
+        abortController
+      }
+    }).then(res => normalizeObjectKeys(res.rows));
+  }
+  async getRange(props) {
+    const {
+        filterOwner,
+        spatialFilter,
+        abortController
+      } = props,
+      params = _objectWithoutPropertiesLoose(props, _excluded3);
+    const {
+      column
+    } = params;
+    return executeModel({
+      model: 'range',
+      source: this.getSource(filterOwner),
+      spatialFilter,
+      params: {
+        column
+      },
+      opts: {
+        abortController
+      }
+    }).then(res => normalizeObjectKeys(res.rows[0]));
+  }
+  async getTable(props) {
+    const {
+        filterOwner,
+        spatialFilter,
+        abortController
+      } = props,
+      params = _objectWithoutPropertiesLoose(props, _excluded4);
+    const {
+      columns,
+      sortBy,
+      sortDirection,
+      page = 0,
+      rowsPerPage = 10
+    } = params;
+    return executeModel({
+      model: 'table',
+      source: this.getSource(filterOwner),
+      spatialFilter,
+      params: {
+        column: columns,
+        sortBy,
+        sortDirection,
+        limit: rowsPerPage,
+        offset: page * rowsPerPage
+      },
+      opts: {
+        abortController
+      }
+    }).then(res => ({
+      rows: normalizeObjectKeys(res.rows),
+      totalCount: res.metadata.total
+    }));
+  }
+  async getScatter(props) {
+    const {
+        filterOwner,
+        spatialFilter,
+        abortController
+      } = props,
+      params = _objectWithoutPropertiesLoose(props, _excluded5);
+    const {
+      xAxisColumn,
+      xAxisJoinOperation,
+      yAxisColumn,
+      yAxisJoinOperation
+    } = params;
+    // Make sure this is sync with the same constant in cloud-native/maps-api
+    const HARD_LIMIT = 500;
+    return executeModel({
+      model: 'scatterplot',
+      source: this.getSource(filterOwner),
+      spatialFilter,
+      params: {
+        xAxisColumn,
+        xAxisJoinOperation,
+        yAxisColumn,
+        yAxisJoinOperation,
+        limit: HARD_LIMIT
+      },
+      opts: {
+        abortController
+      }
+    }).then(res => normalizeObjectKeys(res.rows)).then(res => res.map(({
+      x,
+      y
+    }) => [x, y]));
+  }
+  async getTimeSeries(props) {
+    const {
+        filterOwner,
+        abortController,
+        spatialFilter
+      } = props,
+      params = _objectWithoutPropertiesLoose(props, _excluded6);
+    const {
+      column,
+      operationColumn,
+      joinOperation,
+      operation,
+      stepSize,
+      stepMultiplier,
+      splitByCategory,
+      splitByCategoryLimit,
+      splitByCategoryValues
+    } = params;
+    return executeModel({
+      model: 'timeseries',
+      source: this.getSource(filterOwner),
+      spatialFilter,
+      params: {
+        column,
+        stepSize,
+        stepMultiplier,
+        operationColumn: operationColumn || column,
+        joinOperation,
+        operation,
+        splitByCategory,
+        splitByCategoryLimit,
+        splitByCategoryValues
+      },
+      opts: {
+        abortController
+      }
+    }).then(res => {
+      var _res$metadata;
+      return {
+        rows: normalizeObjectKeys(res.rows),
+        categories: (_res$metadata = res.metadata) == null ? void 0 : _res$metadata.categories
+      };
+    });
+  }
+  async getHistogram(props) {
+    const {
+        filterOwner,
+        spatialFilter,
+        abortController
+      } = props,
+      params = _objectWithoutPropertiesLoose(props, _excluded7);
+    const {
+      column,
+      operation,
+      ticks
+    } = params;
+    const data = await executeModel({
+      model: 'histogram',
+      source: this.getSource(filterOwner),
+      spatialFilter,
+      params: {
+        column,
+        operation,
+        ticks
+      },
+      opts: {
+        abortController
+      }
+    }).then(res => normalizeObjectKeys(res.rows));
+    if (data.length) {
+      // Given N ticks the API returns up to N+1 bins, omitting any empty bins. Bins
+      // include 1 bin below the lowest tick, N-1 between ticks, and 1 bin above the highest tick.
+      const result = Array(ticks.length + 1).fill(0);
+      data.forEach(({
+        tick,
+        value
+      }) => result[tick] = value);
+      return result;
+    }
+    return [];
+  }
+}
+WidgetBaseSource.defaultProps = {
+  filters: {},
+  filtersLogicalOperator: 'and'
+};
+
+class WidgetQuerySource extends WidgetBaseSource {
+  getSource(owner) {
+    return _extends({}, super.getSource(owner), {
+      type: MapType.QUERY,
+      data: this.props.sqlQuery
+    });
+  }
+}
+
+class WidgetTableSource extends WidgetBaseSource {
+  getSource(owner) {
+    return _extends({}, super.getSource(owner), {
+      type: MapType.TABLE,
+      data: this.props.tableName
+    });
+  }
+}
+
+// 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;
+
+/**
+ *
+ * Custom error for reported errors in CARTO Maps API.
+ * Provides useful debugging information in console and context for applications.
+ *
+ */
+class CartoAPIError extends Error {
+  constructor(error, errorContext, response) {
+    let responseString = 'Failed to connect';
+    if (response) {
+      responseString = 'Server returned: ';
+      if (response.status === 400) {
+        responseString += 'Bad request';
+      } else if (response.status === 401 || response.status === 403) {
+        responseString += 'Unauthorized access';
+      } else if (response.status === 404) {
+        responseString += 'Not found';
+      } else {
+        responseString += 'Error';
+      }
+      responseString += ` (${response.status}):`;
+    }
+    responseString += ` ${error.message || error}`;
+    let message = `${errorContext.requestType} API request failed`;
+    message += `\n${responseString}`;
+    for (const key of Object.keys(errorContext)) {
+      if (key === 'requestType') continue; // eslint-disable-line no-continue
+      message += `\n${formatErrorKey(key)}: ${errorContext[key]}`;
+    }
+    message += '\n';
+    super(message);
+    this.name = 'CartoAPIError';
+    this.response = response;
+    this.error = error;
+    this.errorContext = errorContext;
+  }
+}
+/**
+ * Converts camelCase to Camel Case
+ */
+function formatErrorKey(key) {
+  return key.replace(/([A-Z])/g, ' $1').replace(/^./, s => s.toUpperCase());
+}
+
+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.1-0"
+};
+const DEFAULT_HEADERS = {
+  Accept: 'application/json',
+  'Content-Type': 'application/json'
+};
+
+function joinPath(...args) {
+  return args.map(part => part.endsWith('/') ? part.slice(0, -1) : part).join('/');
+}
+function buildV3Path(apiBaseUrl, version, endpoint, ...rest) {
+  return joinPath(apiBaseUrl, version, endpoint, ...rest);
+}
+function buildSourceUrl({
+  apiBaseUrl,
+  connectionName,
+  endpoint
+}) {
+  return buildV3Path(apiBaseUrl, 'v3', 'maps', connectionName, endpoint);
+}
+
+/**
+ * Simple encode parameter
+ */
+function encodeParameter(name, value) {
+  if (isPureObject(value) || Array.isArray(value)) {
+    return `${name}=${encodeURIComponent(JSON.stringify(value))}`;
+  }
+  return `${name}=${encodeURIComponent(value)}`;
+}
+const REQUEST_CACHE = new Map();
+async function requestWithParameters({
+  baseUrl,
+  parameters,
+  headers: customHeaders,
+  errorContext
+}) {
+  parameters = {
+    ...DEFAULT_PARAMETERS,
+    ...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 headers = {
+    ...DEFAULT_HEADERS,
+    ...customHeaders
+  };
+  /* global fetch */
+  const fetchPromise = url.length > MAX_GET_LENGTH ? fetch(baseUrl, {
+    method: 'POST',
+    body: JSON.stringify(parameters),
+    headers
+  }) : fetch(url, {
+    headers
+  });
+  let response;
+  const jsonPromise = fetchPromise.then(_response => {
+    response = _response;
+    return response.json();
+  }).then(json => {
+    if (!response || !response.ok) {
+      throw new Error(json.error);
+    }
+    return json;
+  }).catch(error => {
+    REQUEST_CACHE.delete(key);
+    throw new CartoAPIError(error, errorContext, response);
+  });
+  REQUEST_CACHE.set(key, jsonPromise);
+  return jsonPromise;
+}
+function createCacheKey(baseUrl, parameters, headers) {
+  const parameterEntries = Object.entries(parameters).sort(([a], [b]) => a > b ? 1 : -1);
+  const headerEntries = Object.entries(headers).sort(([a], [b]) => a > b ? 1 : -1);
+  return JSON.stringify({
+    baseUrl,
+    parameters: parameterEntries,
+    headers: headerEntries
+  });
+}
+function createURLWithParameters(baseUrl, parameters) {
+  const encodedParameters = Object.entries(parameters).map(([key, value]) => encodeParameter(key, value));
+  return `${baseUrl}?${encodedParameters.join('&')}`;
+}
+
+/* eslint-disable camelcase */
+const SOURCE_DEFAULTS = {
+  apiBaseUrl: DEFAULT_API_BASE_URL,
+  clientId: DEFAULT_CLIENT,
+  format: 'tilejson',
+  headers: {}
+};
+async function baseSource(endpoint, options, urlParameters) {
+  const {
+    accessToken,
+    connectionName,
+    cache,
+    ...optionalOptions
+  } = options;
+  const mergedOptions = {
+    ...SOURCE_DEFAULTS,
+    accessToken,
+    connectionName,
+    endpoint
+  };
+  for (const key in optionalOptions) {
+    if (optionalOptions[key]) {
+      mergedOptions[key] = optionalOptions[key];
+    }
+  }
+  const baseUrl = buildSourceUrl(mergedOptions);
+  const {
+    clientId,
+    format
+  } = mergedOptions;
+  const headers = {
+    Authorization: `Bearer ${options.accessToken}`,
+    ...options.headers
+  };
+  const parameters = {
+    client: clientId,
+    ...urlParameters
+  };
+  const errorContext = {
+    requestType: 'Map instantiation',
+    connection: options.connectionName,
+    type: endpoint,
+    source: JSON.stringify(parameters, undefined, 2)
+  };
+  const mapInstantiation = await requestWithParameters({
+    baseUrl,
+    parameters,
+    headers,
+    errorContext
+  });
+  const dataUrl = mapInstantiation[format].url[0];
+  if (cache) {
+    cache.value = parseInt(new URL(dataUrl).searchParams.get('cache') || '', 10);
+  }
+  errorContext.requestType = 'Map data';
+  if (format === 'tilejson') {
+    const json = await requestWithParameters({
+      baseUrl: dataUrl,
+      headers,
+      errorContext
+    });
+    if (accessToken) {
+      json.accessToken = accessToken;
+    }
+    return json;
+  }
+  return await requestWithParameters({
+    baseUrl: dataUrl,
+    headers,
+    errorContext
+  });
+}
+
+const boundaryQuerySource = async function (options) {
+  const {
+    columns,
+    filters,
+    tilesetTableName,
+    matchingColumn = 'id',
+    propertiesSqlQuery,
+    queryParameters
+  } = options;
+  const urlParameters = {
+    tilesetTableName,
+    matchingColumn,
+    propertiesSqlQuery
+  };
+  if (columns) {
+    urlParameters.columns = columns.join(',');
+  }
+  if (filters) {
+    urlParameters.filters = filters;
+  }
+  if (queryParameters) {
+    urlParameters.queryParameters = queryParameters;
+  }
+  return baseSource('boundary', options, urlParameters);
+};
+
+const boundaryTableSource = async function (options) {
+  const {
+    filters,
+    tilesetTableName,
+    columns,
+    matchingColumn = 'id',
+    propertiesTableName
+  } = options;
+  const urlParameters = {
+    tilesetTableName,
+    matchingColumn,
+    propertiesTableName
+  };
+  if (columns) {
+    urlParameters.columns = columns.join(',');
+  }
+  if (filters) {
+    urlParameters.filters = filters;
+  }
+  return baseSource('boundary', options, urlParameters);
+};
+
+/* eslint-disable camelcase */
+const h3QuerySource$1 = async function (options) {
+  const {
+    aggregationExp,
+    aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_H3,
+    sqlQuery,
+    spatialDataColumn = 'h3',
+    queryParameters
+  } = options;
+  const urlParameters = {
+    aggregationExp,
+    spatialDataColumn,
+    spatialDataType: 'h3',
+    q: sqlQuery
+  };
+  if (aggregationResLevel) {
+    urlParameters.aggregationResLevel = String(aggregationResLevel);
+  }
+  if (queryParameters) {
+    urlParameters.queryParameters = queryParameters;
+  }
+  return baseSource('query', options, urlParameters);
+};
+
+/* eslint-disable camelcase */
+const h3TableSource$1 = async function (options) {
+  const {
+    aggregationExp,
+    aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_H3,
+    spatialDataColumn = 'h3',
+    tableName
+  } = options;
+  const urlParameters = {
+    aggregationExp,
+    name: tableName,
+    spatialDataColumn,
+    spatialDataType: 'h3'
+  };
+  if (aggregationResLevel) {
+    urlParameters.aggregationResLevel = String(aggregationResLevel);
+  }
+  return baseSource('table', options, urlParameters);
+};
+
+const h3TilesetSource$1 = async function (options) {
+  const {
+    tableName
+  } = options;
+  const urlParameters = {
+    name: tableName
+  };
+  return baseSource('tileset', options, urlParameters);
+};
+
+const rasterSource = async function (options) {
+  const {
+    tableName
+  } = options;
+  const urlParameters = {
+    name: tableName
+  };
+  return baseSource('raster', options, urlParameters);
+};
+
+/* eslint-disable camelcase */
+const quadbinQuerySource$1 = async function (options) {
+  const {
+    aggregationExp,
+    aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN,
+    sqlQuery,
+    spatialDataColumn = 'quadbin',
+    queryParameters
+  } = options;
+  const urlParameters = {
+    aggregationExp,
+    q: sqlQuery,
+    spatialDataColumn,
+    spatialDataType: 'quadbin'
+  };
+  if (aggregationResLevel) {
+    urlParameters.aggregationResLevel = String(aggregationResLevel);
+  }
+  if (queryParameters) {
+    urlParameters.queryParameters = queryParameters;
+  }
+  return baseSource('query', options, urlParameters);
+};
+
+/* eslint-disable camelcase */
+const quadbinTableSource$1 = async function (options) {
+  const {
+    aggregationExp,
+    aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN,
+    spatialDataColumn = 'quadbin',
+    tableName
+  } = options;
+  const urlParameters = {
+    aggregationExp,
+    name: tableName,
+    spatialDataColumn,
+    spatialDataType: 'quadbin'
+  };
+  if (aggregationResLevel) {
+    urlParameters.aggregationResLevel = String(aggregationResLevel);
+  }
+  return baseSource('table', options, urlParameters);
+};
+
+const quadbinTilesetSource$1 = async function (options) {
+  const {
+    tableName
+  } = options;
+  const urlParameters = {
+    name: tableName
+  };
+  return baseSource('tileset', options, urlParameters);
+};
+
+/* eslint-disable camelcase */
+const vectorQuerySource$1 = async function (options) {
+  const {
+    columns,
+    filters,
+    spatialDataColumn = 'geom',
+    sqlQuery,
+    tileResolution = DEFAULT_TILE_RESOLUTION,
+    queryParameters
+  } = options;
+  const urlParameters = {
+    spatialDataColumn,
+    spatialDataType: 'geo',
+    tileResolution: tileResolution.toString(),
+    q: sqlQuery
+  };
+  if (columns) {
+    urlParameters.columns = columns.join(',');
+  }
+  if (filters) {
+    urlParameters.filters = filters;
+  }
+  if (queryParameters) {
+    urlParameters.queryParameters = queryParameters;
+  }
+  return baseSource('query', options, urlParameters);
+};
+
+/* eslint-disable camelcase */
+const vectorTableSource$1 = async function (options) {
+  const {
+    columns,
+    filters,
+    spatialDataColumn = 'geom',
+    tableName,
+    tileResolution = DEFAULT_TILE_RESOLUTION
+  } = options;
+  const urlParameters = {
+    name: tableName,
+    spatialDataColumn,
+    spatialDataType: 'geo',
+    tileResolution: tileResolution.toString()
+  };
+  if (columns) {
+    urlParameters.columns = columns.join(',');
+  }
+  if (filters) {
+    urlParameters.filters = filters;
+  }
+  return baseSource('table', options, urlParameters);
+};
+
+const vectorTilesetSource$1 = async function (options) {
+  const {
+    tableName
+  } = options;
+  const urlParameters = {
+    name: tableName
+  };
+  return baseSource('tileset', options, urlParameters);
+};
+
+({
+  boundaryQuerySource,
+  boundaryTableSource,
+  h3QuerySource: h3QuerySource$1,
+  h3TableSource: h3TableSource$1,
+  h3TilesetSource: h3TilesetSource$1,
+  rasterSource,
+  quadbinQuerySource: quadbinQuerySource$1,
+  quadbinTableSource: quadbinTableSource$1,
+  quadbinTilesetSource: quadbinTilesetSource$1,
+  vectorQuerySource: vectorQuerySource$1,
+  vectorTableSource: vectorTableSource$1,
+  vectorTilesetSource: vectorTilesetSource$1
+});
+
+/******************************************************************************
+ * VECTOR SOURCES
+ */
+/** Wrapper adding widget support to {@link _vectorTableSource}. */
+async function vectorTableSource(props) {
+  const response = await vectorTableSource$1(props);
+  return _extends({}, response, {
+    widgetSource: new WidgetTableSource(props)
+  });
+}
+/** Wrapper adding widget support to {@link _vectorQuerySource}. */
+async function vectorQuerySource(props) {
+  const response = await vectorQuerySource$1(props);
+  return _extends({}, response, {
+    widgetSource: new WidgetQuerySource(props)
+  });
+}
+/** Wrapper adding widget support to {@link _vectorTilesetSource}. */
+async function vectorTilesetSource() {
+  throw new Error('not implemented');
+}
+/******************************************************************************
+ * H3 SOURCES
+ */
+/** Wrapper adding widget support to {@link _h3TableSource}. */
+async function h3TableSource(props) {
+  const response = await h3TableSource$1(props);
+  return _extends({}, response, {
+    widgetSource: new WidgetTableSource(props)
+  });
+}
+/** Wrapper adding widget support to {@link _h3QuerySource}. */
+async function h3QuerySource(props) {
+  const response = await h3QuerySource$1(props);
+  return _extends({}, response, {
+    widgetSource: new WidgetQuerySource(props)
+  });
+}
+/** Wrapper adding widget support to {@link _h3TilesetSource}. */
+async function h3TilesetSource() {
+  throw new Error('not implemented');
+}
+/******************************************************************************
+ * QUADBIN SOURCES
+ */
+/** Wrapper adding widget support to {@link _quadbinTableSource}. */
+async function quadbinTableSource(props) {
+  const response = await quadbinTableSource$1(props);
+  return _extends({}, response, {
+    widgetSource: new WidgetTableSource(props)
+  });
+}
+/** Wrapper adding widget support to {@link _quadbinQuerySource}. */
+async function quadbinQuerySource(props) {
+  const response = await quadbinQuerySource$1(props);
+  return _extends({}, response, {
+    widgetSource: new WidgetQuerySource(props)
+  });
+}
+/** Wrapper adding widget support to {@link _quadbinTilesetSource}. */
+async function quadbinTilesetSource() {
+  throw new Error('not implemented');
+}
+
+export { ApiVersion, CLIENT_ID, FilterType, GroupDateType, MapType, WidgetBaseSource, WidgetQuerySource, WidgetTableSource, executeModel, getClient, h3QuerySource, h3TableSource, h3TilesetSource, quadbinQuerySource, quadbinTableSource, quadbinTilesetSource, setClient, vectorQuerySource, vectorTableSource, vectorTilesetSource };
+//# sourceMappingURL=api-client.modern.js.map