@deck.gl/carto 9.0.0-beta.1 → 9.0.0-beta.3

package/dist/api/carto-api-error.js

@@ -0,0 +1,47 @@
+/**
+ *
+ * Custom error for reported errors in CARTO Maps API.
+ * Provides useful debugging information in console and context for applications.
+ *
+ */
+export 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());
+}

package/dist/{esm/api → api}/common.js

@@ -3,11 +3,10 @@ export const DEFAULT_CLIENT = 'deck-gl-carto';
 export const V3_MINOR_VERSION = '3.3';
 export const MAX_GET_LENGTH = 8192;
 export const DEFAULT_PARAMETERS = {
-  client: DEFAULT_CLIENT,
-  v: V3_MINOR_VERSION
+    client: DEFAULT_CLIENT,
+    v: V3_MINOR_VERSION
 };
 export const DEFAULT_HEADERS = {
-  Accept: 'application/json',
-  'Content-Type': 'application/json'
+    Accept: 'application/json',
+    'Content-Type': 'application/json'
 };
-//# sourceMappingURL=common.js.map

package/dist/api/endpoints.js

@@ -0,0 +1,22 @@
+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);
+}
+export function buildPublicMapUrl({ apiBaseUrl, cartoMapId }) {
+    return buildV3Path(apiBaseUrl, 'v3', 'maps', 'public', cartoMapId);
+}
+export function buildStatsUrl({ attribute, apiBaseUrl, connectionName, source, type }) {
+    if (type === 'query') {
+        return buildV3Path(apiBaseUrl, 'v3', 'stats', connectionName, attribute);
+    }
+    // type === 'table'
+    return buildV3Path(apiBaseUrl, 'v3', 'stats', connectionName, source, attribute);
+}
+export function buildSourceUrl({ apiBaseUrl, connectionName, endpoint }) {
+    return buildV3Path(apiBaseUrl, 'v3', 'maps', connectionName, endpoint);
+}
+export function buildQueryUrl({ apiBaseUrl, connectionName }) {
+    return buildV3Path(apiBaseUrl, 'v3', 'sql', connectionName, 'query');
+}

package/dist/api/fetch-map.js

@@ -0,0 +1,187 @@
+/* eslint-disable camelcase */
+/**
+ * Maps API Client for Carto 3
+ */
+import { CartoAPIError } from "./carto-api-error.js";
+import { DEFAULT_API_BASE_URL, DEFAULT_CLIENT } from "./common.js";
+import { buildPublicMapUrl, buildStatsUrl } from "./endpoints.js";
+import { h3QuerySource, h3TableSource, quadbinQuerySource, quadbinTableSource, vectorQuerySource, vectorTableSource, vectorTilesetSource } from "../sources/index.js";
+import { parseMap } from "./parse-map.js";
+import { requestWithParameters } from "./request-with-parameters.js";
+import { assert } from "../utils.js";
+/* global clearInterval, setInterval, URL */
+/* eslint-disable complexity, max-statements */
+async function _fetchMapDataset(dataset, accessToken, apiBaseUrl, clientId, headers) {
+    const { aggregationExp, aggregationResLevel, connectionName, columns, format, geoColumn, source, type, queryParameters } = dataset;
+    const cache = {};
+    const globalOptions = {
+        accessToken,
+        apiBaseUrl,
+        cache,
+        clientId,
+        connectionName,
+        format,
+        headers
+    };
+    if (type === 'tileset') {
+        // TODO do we want a generic tilesetSource?
+        // @ts-ignore
+        dataset.data = await vectorTilesetSource({ ...globalOptions, tableName: source });
+    }
+    else {
+        const [spatialDataType, spatialDataColumn] = geoColumn ? geoColumn.split(':') : ['geom'];
+        if (spatialDataType === 'geom') {
+            const options = { ...globalOptions, spatialDataColumn };
+            if (type === 'table') {
+                dataset.data = await vectorTableSource({ ...options, columns, tableName: source });
+            }
+            else if (type === 'query') {
+                dataset.data = await vectorQuerySource({ ...options, sqlQuery: source, queryParameters });
+            }
+        }
+        else if (spatialDataType === 'h3') {
+            const options = { ...globalOptions, aggregationExp, aggregationResLevel, spatialDataColumn };
+            if (type === 'table') {
+                dataset.data = await h3TableSource({ ...options, columns, tableName: source });
+            }
+            else if (type === 'query') {
+                dataset.data = await h3QuerySource({ ...options, sqlQuery: source, queryParameters });
+            }
+        }
+        else if (spatialDataType === 'quadbin') {
+            const options = { ...globalOptions, aggregationExp, aggregationResLevel, spatialDataColumn };
+            if (type === 'table') {
+                dataset.data = await quadbinTableSource({ ...options, columns, tableName: source });
+            }
+            else if (type === 'query') {
+                dataset.data = await quadbinQuerySource({ ...options, sqlQuery: source, queryParameters });
+            }
+        }
+    }
+    let cacheChanged = true;
+    if (cache.value) {
+        cacheChanged = dataset.cache !== cache.value;
+        dataset.cache = cache.value;
+    }
+    return cacheChanged;
+}
+async function _fetchTilestats(attribute, dataset, accessToken, apiBaseUrl) {
+    const { connectionName, data, id, source, type, queryParameters } = dataset;
+    const errorContext = {
+        requestType: 'Tile stats',
+        connection: connectionName,
+        type,
+        source
+    };
+    if (!('tilestats' in data)) {
+        throw new CartoAPIError(new Error(`Invalid dataset for tilestats: ${id}`), errorContext);
+    }
+    const baseUrl = buildStatsUrl({ attribute, apiBaseUrl, ...dataset });
+    const headers = { Authorization: `Bearer ${accessToken}` };
+    const parameters = {};
+    if (type === 'query') {
+        parameters.q = source;
+        if (queryParameters) {
+            parameters.queryParameters = JSON.stringify(queryParameters);
+        }
+    }
+    const stats = await requestWithParameters({
+        baseUrl,
+        headers,
+        parameters,
+        errorContext
+    });
+    // Replace tilestats for attribute with value from API
+    const { attributes } = data.tilestats.layers[0];
+    const index = attributes.findIndex(d => d.attribute === attribute);
+    attributes[index] = stats;
+    return true;
+}
+async function fillInMapDatasets({ datasets, token }, clientId, apiBaseUrl, headers) {
+    const promises = datasets.map(dataset => _fetchMapDataset(dataset, token, apiBaseUrl, clientId, headers));
+    return await Promise.all(promises);
+}
+async function fillInTileStats({ datasets, keplerMapConfig, token }, apiBaseUrl) {
+    const attributes = [];
+    const { layers } = keplerMapConfig.config.visState;
+    for (const layer of layers) {
+        for (const channel of Object.keys(layer.visualChannels)) {
+            const attribute = layer.visualChannels[channel]?.name;
+            if (attribute) {
+                const dataset = datasets.find(d => d.id === layer.config.dataId);
+                if (dataset && dataset.type !== 'tileset' && dataset.data.tilestats) {
+                    // Only fetch stats for QUERY & TABLE map types
+                    attributes.push({ attribute, dataset });
+                }
+            }
+        }
+    }
+    // Remove duplicates to avoid repeated requests
+    const filteredAttributes = [];
+    for (const a of attributes) {
+        if (!filteredAttributes.find(({ attribute, dataset }) => attribute === a.attribute && dataset === a.dataset)) {
+            filteredAttributes.push(a);
+        }
+    }
+    const promises = filteredAttributes.map(({ attribute, dataset }) => _fetchTilestats(attribute, dataset, token, apiBaseUrl));
+    return await Promise.all(promises);
+}
+/* eslint-disable max-statements */
+export async function fetchMap({ apiBaseUrl = DEFAULT_API_BASE_URL, cartoMapId, clientId = DEFAULT_CLIENT, headers = {}, autoRefresh, onNewData }) {
+    assert(cartoMapId, 'Must define CARTO map id: fetchMap({cartoMapId: "XXXX-XXXX-XXXX"})');
+    assert(apiBaseUrl, 'Must define apiBaseUrl');
+    if (autoRefresh || onNewData) {
+        assert(onNewData, 'Must define `onNewData` when using autoRefresh');
+        assert(typeof onNewData === 'function', '`onNewData` must be a function');
+        assert(typeof autoRefresh === 'number' && autoRefresh > 0, '`autoRefresh` must be a positive number');
+    }
+    const baseUrl = buildPublicMapUrl({ apiBaseUrl, cartoMapId });
+    const errorContext = { requestType: 'Public map', mapId: cartoMapId };
+    const map = await requestWithParameters({ baseUrl, headers, errorContext });
+    // Periodically check if the data has changed. Note that this
+    // will not update when a map is published.
+    let stopAutoRefresh;
+    if (autoRefresh) {
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        const intervalId = setInterval(async () => {
+            const changed = await fillInMapDatasets(map, clientId, apiBaseUrl, {
+                ...headers,
+                'If-Modified-Since': new Date().toUTCString()
+            });
+            if (onNewData && changed.some(v => v === true)) {
+                onNewData(parseMap(map));
+            }
+        }, autoRefresh * 1000);
+        stopAutoRefresh = () => {
+            clearInterval(intervalId);
+        };
+    }
+    const geojsonLayers = map.keplerMapConfig.config.visState.layers.filter(({ type }) => type === 'geojson' || type === 'point');
+    const geojsonDatasetIds = geojsonLayers.map(({ config }) => config.dataId);
+    map.datasets.forEach(dataset => {
+        if (geojsonDatasetIds.includes(dataset.id)) {
+            const { config } = geojsonLayers.find(({ config }) => config.dataId === dataset.id);
+            dataset.format = 'geojson';
+            // Support for very old maps. geoColumn was not stored in the past
+            if (!dataset.geoColumn && config.columns.geojson) {
+                dataset.geoColumn = config.columns.geojson;
+            }
+        }
+    });
+    // Mutates map.datasets so that dataset.data contains data
+    await fillInMapDatasets(map, clientId, apiBaseUrl, headers);
+    // Mutates attributes in visualChannels to contain tile stats
+    await fillInTileStats(map, apiBaseUrl);
+    const out = { ...parseMap(map), ...{ stopAutoRefresh } };
+    const textLayers = out.layers.filter(layer => {
+        const pointType = layer.props.pointType || '';
+        return pointType.includes('text');
+    });
+    /* global FontFace, window, document */
+    if (textLayers.length && window.FontFace && !document.fonts.check('12px Inter')) {
+        // Fetch font needed for labels
+        const font = new FontFace('Inter', 'url(https://fonts.gstatic.com/s/inter/v12/UcC73FwrK3iLTeHuS_fvQtMwCp50KnMa1ZL7W0Q5nw.woff2)');
+        await font.load().then(f => document.fonts.add(f));
+    }
+    return out;
+}

package/dist/api/index.js

@@ -0,0 +1,3 @@
+export { CartoAPIError } from "./carto-api-error.js";
+export { fetchMap } from "./fetch-map.js";
+export { query } from "./query.js";

package/dist/api/layer-map.js

@@ -0,0 +1,373 @@
+import { deviation, extent, groupSort, median, variance } from 'd3-array';
+import { rgb } from 'd3-color';
+import { scaleLinear, scaleOrdinal, scaleLog, scalePoint, scaleQuantile, scaleQuantize, scaleSqrt, scaleThreshold } from 'd3-scale';
+import { format as d3Format } from 'd3-format';
+import moment from 'moment-timezone';
+import { CPUGridLayer, HeatmapLayer, HexagonLayer } from '@deck.gl/aggregation-layers';
+import { GeoJsonLayer } from '@deck.gl/layers';
+import { H3HexagonLayer } from '@deck.gl/geo-layers';
+import H3TileLayer from "../layers/h3-tile-layer.js";
+import QuadbinTileLayer from "../layers/quadbin-tile-layer.js";
+import RasterTileLayer from "../layers/raster-tile-layer.js";
+import VectorTileLayer from "../layers/vector-tile-layer.js";
+import { assert, createBinaryProxy, scaleIdentity } from "../utils.js";
+const SCALE_FUNCS = {
+    linear: scaleLinear,
+    ordinal: scaleOrdinal,
+    log: scaleLog,
+    point: scalePoint,
+    quantile: scaleQuantile,
+    quantize: scaleQuantize,
+    sqrt: scaleSqrt,
+    custom: scaleThreshold,
+    identity: scaleIdentity
+};
+function identity(v) {
+    return v;
+}
+const UNKNOWN_COLOR = '#868d91';
+export const AGGREGATION = {
+    average: 'MEAN',
+    maximum: 'MAX',
+    minimum: 'MIN',
+    sum: 'SUM'
+};
+export const OPACITY_MAP = {
+    getFillColor: 'opacity',
+    getLineColor: 'strokeOpacity',
+    getTextColor: 'opacity'
+};
+const AGGREGATION_FUNC = {
+    'count unique': (values, accessor) => groupSort(values, v => v.length, accessor).length,
+    median,
+    // Unfortunately mode() is only available in d3-array@3+ which is ESM only
+    mode: (values, accessor) => groupSort(values, v => v.length, accessor).pop(),
+    stddev: deviation,
+    variance
+};
+const hexToRGBA = c => {
+    const { r, g, b, opacity } = rgb(c);
+    return [r, g, b, 255 * opacity];
+};
+// Kepler prop value -> Deck.gl prop value
+// Supports nested definitions, and function transforms:
+//   {keplerProp: 'deckProp'} is equivalent to:
+//   {keplerProp: x => ({deckProp: x})}
+const sharedPropMap = {
+    // Apply the value of Kepler `color` prop to the deck `getFillColor` prop
+    color: 'getFillColor',
+    isVisible: 'visible',
+    label: 'cartoLabel',
+    textLabel: {
+        alignment: 'getTextAlignmentBaseline',
+        anchor: 'getTextAnchor',
+        // Apply the value of Kepler `textLabel.color` prop to the deck `getTextColor` prop
+        color: 'getTextColor',
+        size: 'getTextSize'
+    },
+    visConfig: {
+        enable3d: 'extruded',
+        elevationScale: 'elevationScale',
+        filled: 'filled',
+        strokeColor: 'getLineColor',
+        stroked: 'stroked',
+        thickness: 'getLineWidth',
+        radius: 'getPointRadius',
+        wireframe: 'wireframe'
+    }
+};
+const customMarkersPropsMap = {
+    color: 'getIconColor',
+    visConfig: {
+        radius: 'getIconSize'
+    }
+};
+const aggregationVisConfig = {
+    colorAggregation: x => ({ colorAggregation: AGGREGATION[x] || AGGREGATION.sum }),
+    colorRange: x => ({ colorRange: x.colors.map(hexToRGBA) }),
+    coverage: 'coverage',
+    elevationPercentile: ['elevationLowerPercentile', 'elevationUpperPercentile'],
+    percentile: ['lowerPercentile', 'upperPercentile']
+};
+const defaultProps = {
+    lineMiterLimit: 2,
+    lineWidthUnits: 'pixels',
+    pointRadiusUnits: 'pixels',
+    rounded: true,
+    wrapLongitude: false
+};
+function mergePropMaps(a = {}, b = {}) {
+    return { ...a, ...b, visConfig: { ...a.visConfig, ...b.visConfig } };
+}
+export function getLayer(type, config, dataset) {
+    let basePropMap = sharedPropMap;
+    if (config.visConfig?.customMarkers) {
+        basePropMap = mergePropMaps(sharedPropMap, customMarkersPropsMap);
+    }
+    if (type === 'mvt' || type === 'tileset' || type === 'h3' || type === 'quadbin') {
+        return getTileLayer(dataset, basePropMap);
+    }
+    const geoColumn = dataset?.geoColumn;
+    const getPosition = d => d[geoColumn].coordinates;
+    const hexagonId = config.columns?.hex_id;
+    const layerTypeDefs = {
+        point: {
+            Layer: GeoJsonLayer,
+            propMap: {
+                columns: {
+                    altitude: x => ({ parameters: { depthTest: Boolean(x) } })
+                },
+                visConfig: { outline: 'stroked' }
+            }
+        },
+        geojson: {
+            Layer: GeoJsonLayer
+        },
+        grid: {
+            Layer: CPUGridLayer,
+            propMap: { visConfig: { ...aggregationVisConfig, worldUnitSize: x => ({ cellSize: 1000 * x }) } },
+            defaultProps: { getPosition }
+        },
+        heatmap: {
+            Layer: HeatmapLayer,
+            propMap: { visConfig: { ...aggregationVisConfig, radius: 'radiusPixels' } },
+            defaultProps: { getPosition }
+        },
+        hexagon: {
+            Layer: HexagonLayer,
+            propMap: { visConfig: { ...aggregationVisConfig, worldUnitSize: x => ({ radius: 1000 * x }) } },
+            defaultProps: { getPosition }
+        },
+        hexagonId: {
+            Layer: H3HexagonLayer,
+            propMap: { visConfig: { coverage: 'coverage' } },
+            defaultProps: { getHexagon: d => d[hexagonId], stroked: false }
+        }
+    };
+    const layer = layerTypeDefs[type];
+    assert(layer, `Unsupported layer type: ${type}`);
+    return {
+        ...layer,
+        propMap: mergePropMaps(basePropMap, layer.propMap),
+        defaultProps: { ...defaultProps, ...layer.defaultProps }
+    };
+}
+export function layerFromTileDataset(scheme, type) {
+    if (type === 'raster') {
+        return RasterTileLayer;
+    }
+    if (scheme === 'h3') {
+        return H3TileLayer;
+    }
+    if (scheme === 'quadbin') {
+        return QuadbinTileLayer;
+    }
+    return VectorTileLayer;
+}
+function getTileLayer(dataset, basePropMap) {
+    const { aggregationExp, aggregationResLevel, data: { scheme } } = dataset;
+    return {
+        Layer: layerFromTileDataset(scheme),
+        propMap: basePropMap,
+        defaultProps: {
+            ...defaultProps,
+            ...(aggregationExp && { aggregationExp }),
+            ...(aggregationResLevel && { aggregationResLevel }),
+            uniqueIdProperty: 'geoid'
+        }
+    };
+}
+function domainFromAttribute(attribute, scaleType, scaleLength) {
+    if (scaleType === 'ordinal' || scaleType === 'point') {
+        return attribute.categories.map(c => c.category).filter(c => c !== undefined && c !== null);
+    }
+    if (scaleType === 'quantile' && attribute.quantiles) {
+        return attribute.quantiles.global
+            ? attribute.quantiles.global[scaleLength]
+            : attribute.quantiles[scaleLength];
+    }
+    let { min } = attribute;
+    if (scaleType === 'log' && min === 0) {
+        min = 1e-5;
+    }
+    return [min, attribute.max];
+}
+function domainFromValues(values, scaleType) {
+    if (scaleType === 'ordinal' || scaleType === 'point') {
+        return groupSort(values, g => -g.length, d => d);
+    }
+    else if (scaleType === 'quantile') {
+        return values.sort((a, b) => a - b);
+    }
+    else if (scaleType === 'log') {
+        const [d0, d1] = extent(values);
+        return [d0 === 0 ? 1e-5 : d0, d1];
+    }
+    return extent(values);
+}
+function calculateDomain(data, name, scaleType, scaleLength) {
+    if (data.tilestats) {
+        // Tileset data type
+        const { attributes } = data.tilestats.layers[0];
+        const attribute = attributes.find(a => a.attribute === name);
+        return domainFromAttribute(attribute, scaleType, scaleLength);
+    }
+    else if (data.features) {
+        // GeoJSON data type
+        const values = data.features.map(({ properties }) => properties[name]);
+        return domainFromValues(values, scaleType);
+    }
+    else if (Array.isArray(data) && data[0][name] !== undefined) {
+        // JSON data type
+        const values = data.map(properties => properties[name]);
+        return domainFromValues(values, scaleType);
+    }
+    return [0, 1];
+}
+function normalizeAccessor(accessor, data) {
+    if (data.features || data.tilestats) {
+        return (object, info) => {
+            if (object) {
+                return accessor(object.properties || object.__source.object.properties);
+            }
+            const { data, index } = info;
+            const proxy = createBinaryProxy(data, index);
+            return accessor(proxy);
+        };
+    }
+    return accessor;
+}
+export function opacityToAlpha(opacity) {
+    return opacity !== undefined ? Math.round(255 * Math.pow(opacity, 1 / 2.2)) : 255;
+}
+function getAccessorKeys(name, aggregation) {
+    let keys = [name];
+    if (aggregation) {
+        // Snowflake will capitalized the keys, need to check lower and upper case version
+        keys = keys.concat([aggregation, aggregation.toUpperCase()].map(a => `${name}_${a}`));
+    }
+    return keys;
+}
+function findAccessorKey(keys, properties) {
+    for (const key of keys) {
+        if (key in properties) {
+            return [key];
+        }
+    }
+    throw new Error(`Could not find property for any accessor key: ${keys}`);
+}
+export function getColorValueAccessor({ name }, colorAggregation, data) {
+    const aggregator = AGGREGATION_FUNC[colorAggregation];
+    const accessor = values => aggregator(values, p => p[name]);
+    return normalizeAccessor(accessor, data);
+}
+export function getColorAccessor({ name, colorColumn }, scaleType, { aggregation, range }, opacity, data) {
+    const scale = calculateLayerScale(colorColumn || name, scaleType, range, data);
+    const alpha = opacityToAlpha(opacity);
+    let accessorKeys = getAccessorKeys(name, aggregation);
+    const accessor = properties => {
+        if (!(accessorKeys[0] in properties)) {
+            accessorKeys = findAccessorKey(accessorKeys, properties);
+        }
+        const propertyValue = properties[accessorKeys[0]];
+        const { r, g, b } = rgb(scale(propertyValue));
+        return [r, g, b, propertyValue === null ? 0 : alpha];
+    };
+    return normalizeAccessor(accessor, data);
+}
+function calculateLayerScale(name, scaleType, range, data) {
+    const scale = SCALE_FUNCS[scaleType]();
+    let domain = [];
+    let scaleColor = [];
+    if (scaleType !== 'identity') {
+        const { colorMap, colors } = range;
+        if (Array.isArray(colorMap)) {
+            colorMap.forEach(([value, color]) => {
+                domain.push(value);
+                scaleColor.push(color);
+            });
+        }
+        else {
+            domain = calculateDomain(data, name, scaleType, colors.length);
+            scaleColor = colors;
+        }
+        if (scaleType === 'ordinal') {
+            domain = domain.slice(0, scaleColor.length);
+        }
+    }
+    scale.domain(domain);
+    scale.range(scaleColor);
+    scale.unknown(UNKNOWN_COLOR);
+    return scale;
+}
+const FALLBACK_ICON = 'data:image/svg+xml;charset=utf-8;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMTAwIDEwMCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4NCiAgPGNpcmNsZSBjeD0iNTAiIGN5PSI1MCIgcj0iNTAiLz4NCjwvc3ZnPg==';
+export function getIconUrlAccessor(field, range, { fallbackUrl, maxIconSize, useMaskedIcons }, data) {
+    const urlToUnpackedIcon = (url) => ({
+        id: `${url}@@${maxIconSize}`,
+        url,
+        width: maxIconSize,
+        height: maxIconSize,
+        mask: useMaskedIcons
+    });
+    let unknownValue = fallbackUrl || FALLBACK_ICON;
+    if (range?.othersMarker) {
+        unknownValue = range.othersMarker;
+    }
+    const unknownIcon = urlToUnpackedIcon(unknownValue);
+    if (!range || !field) {
+        return () => unknownIcon;
+    }
+    const mapping = {};
+    for (const { value, markerUrl } of range.markerMap) {
+        if (markerUrl) {
+            mapping[value] = urlToUnpackedIcon(markerUrl);
+        }
+    }
+    const accessor = properties => {
+        const propertyValue = properties[field.name];
+        return mapping[propertyValue] || unknownIcon;
+    };
+    return normalizeAccessor(accessor, data);
+}
+export function getMaxMarkerSize(visConfig, visualChannels) {
+    const { radiusRange, radius } = visConfig;
+    const { radiusField, sizeField } = visualChannels;
+    const field = radiusField || sizeField;
+    return Math.ceil(radiusRange && field ? radiusRange[1] : radius);
+}
+export function negateAccessor(accessor) {
+    return typeof accessor === 'function' ? (d, i) => -accessor(d, i) : -accessor;
+}
+export function getSizeAccessor({ name }, scaleType, aggregation, range, data) {
+    const scale = scaleType ? SCALE_FUNCS[scaleType]() : identity;
+    if (scaleType) {
+        if (aggregation !== 'count') {
+            scale.domain(calculateDomain(data, name, scaleType));
+        }
+        scale.range(range);
+    }
+    let accessorKeys = getAccessorKeys(name, aggregation);
+    const accessor = properties => {
+        if (!(accessorKeys[0] in properties)) {
+            accessorKeys = findAccessorKey(accessorKeys, properties);
+        }
+        const propertyValue = properties[accessorKeys[0]];
+        return scale(propertyValue);
+    };
+    return normalizeAccessor(accessor, data);
+}
+const FORMATS = {
+    date: s => moment.utc(s).format('MM/DD/YY HH:mm:ssa'),
+    integer: d3Format('i'),
+    float: d3Format('.5f'),
+    timestamp: s => moment.utc(s).format('X'),
+    default: String
+};
+export function getTextAccessor({ name, type }, data) {
+    const format = FORMATS[type] || FORMATS.default;
+    const accessor = properties => {
+        return format(properties[name]);
+    };
+    return normalizeAccessor(accessor, data);
+}
+export { domainFromValues as _domainFromValues };