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

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 };

package/dist/api/parse-map.js

@@ -0,0 +1,250 @@
+import { GL } from '@luma.gl/constants';
+import { log } from '@deck.gl/core';
+import { AGGREGATION, getLayer, getColorAccessor, getColorValueAccessor, getSizeAccessor, getTextAccessor, OPACITY_MAP, opacityToAlpha, getIconUrlAccessor, negateAccessor, getMaxMarkerSize } from "./layer-map.js";
+import PointLabelLayer from "../layers/point-label-layer.js";
+import { CollisionFilterExtension } from '@deck.gl/extensions';
+import { assert } from "../utils.js";
+const collisionFilterExtension = new CollisionFilterExtension();
+export function parseMap(json) {
+    const { keplerMapConfig, datasets, token } = json;
+    assert(keplerMapConfig.version === 'v1', 'Only support Kepler v1');
+    const { mapState, mapStyle } = keplerMapConfig.config;
+    const { layers, layerBlending, interactionConfig } = keplerMapConfig.config.visState;
+    return {
+        id: json.id,
+        title: json.title,
+        description: json.description,
+        createdAt: json.createdAt,
+        updatedAt: json.updatedAt,
+        initialViewState: mapState,
+        mapStyle,
+        token,
+        layers: layers.reverse().map(({ id, type, config, visualChannels }) => {
+            try {
+                const { dataId } = config;
+                const dataset = datasets.find(d => d.id === dataId);
+                assert(dataset, `No dataset matching dataId: ${dataId}`);
+                const { data } = dataset;
+                assert(data, `No data loaded for dataId: ${dataId}`);
+                const { Layer, propMap, defaultProps } = getLayer(type, config, dataset);
+                const styleProps = createStyleProps(config, propMap);
+                return new Layer({
+                    id,
+                    data,
+                    ...defaultProps,
+                    ...createInteractionProps(interactionConfig),
+                    ...styleProps,
+                    ...createChannelProps(id, type, config, visualChannels, data), // Must come after style
+                    ...createParametersProp(layerBlending, styleProps.parameters || {}), // Must come after style
+                    ...createLoadOptions(token)
+                });
+            }
+            catch (e) {
+                log.error(e.message)();
+                return undefined;
+            }
+        })
+    };
+}
+function createParametersProp(layerBlending, parameters) {
+    if (layerBlending === 'additive') {
+        parameters.blendFunc = [770, 772];
+        parameters.blendEquation = 32774;
+    }
+    else if (layerBlending === 'subtractive') {
+        parameters.blendFunc = [1, 775, 770, 772];
+        parameters.blendEquation = [32778, 32774];
+    }
+    return Object.keys(parameters).length ? { parameters } : {};
+}
+function createInteractionProps(interactionConfig) {
+    const pickable = interactionConfig && interactionConfig.tooltip.enabled;
+    return {
+        autoHighlight: pickable,
+        pickable
+    };
+}
+function mapProps(source, target, mapping) {
+    for (const sourceKey in mapping) {
+        const sourceValue = source[sourceKey];
+        const targetKey = mapping[sourceKey];
+        if (sourceValue === undefined) {
+            // eslint-disable-next-line no-continue
+            continue;
+        }
+        if (typeof targetKey === 'string') {
+            target[targetKey] = sourceValue;
+        }
+        else if (typeof targetKey === 'function') {
+            const [key, value] = Object.entries(targetKey(sourceValue))[0];
+            target[key] = value;
+        }
+        else if (typeof targetKey === 'object') {
+            // Nested definition, recurse down one level (also handles arrays)
+            mapProps(sourceValue, target, targetKey);
+        }
+    }
+}
+function createStyleProps(config, mapping) {
+    const result = {};
+    mapProps(config, result, mapping);
+    // Kepler format sometimes omits strokeColor. TODO: remove once we can rely on
+    // `strokeColor` always being set when `stroke: true`.
+    if (result.stroked && !result.getLineColor) {
+        result.getLineColor = result.getFillColor;
+    }
+    for (const colorAccessor in OPACITY_MAP) {
+        if (Array.isArray(result[colorAccessor])) {
+            const color = [...result[colorAccessor]];
+            const opacityKey = OPACITY_MAP[colorAccessor];
+            const opacity = config.visConfig[opacityKey];
+            color[3] = opacityToAlpha(opacity);
+            result[colorAccessor] = color;
+        }
+    }
+    result.highlightColor = config.visConfig.enable3d ? [255, 255, 255, 60] : [252, 242, 26, 255];
+    return result;
+}
+/* eslint-disable complexity, max-statements */
+function createChannelProps(id, type, config, visualChannels, data) {
+    const { colorField, colorScale, radiusField, radiusScale, sizeField, sizeScale, strokeColorField, strokeColorScale } = visualChannels;
+    let { heightField, heightScale } = visualChannels;
+    if (type === 'hexagonId') {
+        heightField = sizeField;
+        heightScale = sizeScale;
+    }
+    const { textLabel, visConfig } = config;
+    const result = {};
+    if (type === 'grid' || type === 'hexagon') {
+        result.colorScaleType = colorScale;
+        if (colorField) {
+            const { colorAggregation } = config.visConfig;
+            if (!AGGREGATION[colorAggregation]) {
+                result.getColorValue = getColorValueAccessor(colorField, colorAggregation, data);
+            }
+            else {
+                result.getColorWeight = d => d[colorField.name];
+            }
+        }
+    }
+    else if (colorField) {
+        const { colorAggregation: aggregation, colorRange: range } = visConfig;
+        result.getFillColor = getColorAccessor(colorField, 
+        // @ts-ignore
+        colorScale, { aggregation, range }, visConfig.opacity, data);
+    }
+    if (type === 'point') {
+        const altitude = config.columns?.altitude;
+        if (altitude) {
+            result.dataTransform = data => {
+                data.features.forEach(({ geometry, properties }) => {
+                    const { type, coordinates } = geometry;
+                    if (type === 'Point') {
+                        coordinates[2] = properties[altitude];
+                    }
+                });
+                return data;
+            };
+        }
+    }
+    if (radiusField || sizeField) {
+        result.getPointRadius = getSizeAccessor(
+        // @ts-ignore
+        radiusField || sizeField, 
+        // @ts-ignore
+        radiusScale || sizeScale, visConfig.sizeAggregation, visConfig.radiusRange || visConfig.sizeRange, data);
+    }
+    if (strokeColorField) {
+        const fallbackOpacity = type === 'point' ? visConfig.opacity : 1;
+        const opacity = visConfig.strokeOpacity !== undefined ? visConfig.strokeOpacity : fallbackOpacity;
+        const { strokeColorAggregation: aggregation, strokeColorRange: range } = visConfig;
+        result.getLineColor = getColorAccessor(strokeColorField, 
+        // @ts-ignore
+        strokeColorScale, 
+        // @ts-ignore
+        { aggregation, range }, opacity, data);
+    }
+    if (heightField && visConfig.enable3d) {
+        result.getElevation = getSizeAccessor(heightField, 
+        // @ts-ignore
+        heightScale, visConfig.heightAggregation, visConfig.heightRange || visConfig.sizeRange, data);
+    }
+    if (visConfig.customMarkers) {
+        const maxIconSize = getMaxMarkerSize(visConfig, visualChannels);
+        const { getPointRadius, getFillColor } = result;
+        const { customMarkersUrl, customMarkersRange, filled: useMaskedIcons } = visConfig;
+        result.pointType = 'icon';
+        result.getIcon = getIconUrlAccessor(visualChannels.customMarkersField, customMarkersRange, { fallbackUrl: customMarkersUrl, maxIconSize, useMaskedIcons }, data);
+        result._subLayerProps = {
+            'points-icon': {
+                loadOptions: {
+                    image: {
+                        type: 'imagebitmap'
+                    },
+                    imagebitmap: {
+                        resizeWidth: maxIconSize,
+                        resizeHeight: maxIconSize,
+                        resizeQuality: 'high'
+                    }
+                }
+            }
+        };
+        if (getFillColor && useMaskedIcons) {
+            result.getIconColor = getFillColor;
+        }
+        if (getPointRadius) {
+            result.getIconSize = getPointRadius;
+        }
+        if (visualChannels.rotationField) {
+            result.getIconAngle = negateAccessor(getSizeAccessor(visualChannels.rotationField, undefined, null, undefined, data));
+        }
+    }
+    else if (type === 'point' || type === 'tileset') {
+        result.pointType = 'circle';
+    }
+    if (textLabel && textLabel.length && textLabel[0].field) {
+        const [mainLabel, secondaryLabel] = textLabel;
+        const collisionGroup = id;
+        ({
+            alignment: result.getTextAlignmentBaseline,
+            anchor: result.getTextAnchor,
+            color: result.getTextColor,
+            outlineColor: result.textOutlineColor,
+            size: result.textSizeScale
+        } = mainLabel);
+        const { color: getSecondaryColor, field: secondaryField, outlineColor: secondaryOutlineColor, size: secondarySizeScale } = secondaryLabel || {};
+        result.getText = mainLabel.field && getTextAccessor(mainLabel.field, data);
+        const getSecondaryText = secondaryField && getTextAccessor(secondaryField, data);
+        result.pointType = `${result.pointType}+text`;
+        result.textCharacterSet = 'auto';
+        result.textFontFamily = 'Inter, sans';
+        result.textFontSettings = { sdf: true };
+        result.textFontWeight = 600;
+        result.textOutlineWidth = 3;
+        result._subLayerProps = {
+            ...result._subLayerProps,
+            'points-text': {
+                type: PointLabelLayer,
+                extensions: [collisionFilterExtension],
+                collisionEnabled: true,
+                collisionGroup,
+                // getPointRadius already has radiusScale baked in, so only pass one or the other
+                ...(result.getPointRadius
+                    ? { getRadius: result.getPointRadius }
+                    : { radiusScale: visConfig.radius }),
+                ...(secondaryField && {
+                    getSecondaryText,
+                    getSecondaryColor,
+                    secondarySizeScale,
+                    secondaryOutlineColor
+                })
+            }
+        };
+    }
+    return result;
+}
+function createLoadOptions(accessToken) {
+    return {
+        loadOptions: { fetch: { headers: { Authorization: `Bearer ${accessToken}` } } }
+    };
+}

package/{typed → dist}/api/query.d.ts

@@ -1,4 +1,4 @@
-import type { SourceOptions, QuerySourceOptions, QueryResult } from '../sources/types';
+import type { SourceOptions, QuerySourceOptions, QueryResult } from "../sources/types.js";
 export type QueryOptions = SourceOptions & Omit<QuerySourceOptions, 'spatialDataColumn'>;
 export declare const query: (options: QueryOptions) => Promise<QueryResult>;
 //# sourceMappingURL=query.d.ts.map

package/dist/api/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/api/query.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,aAAa,EAAE,kBAAkB,EAAE,WAAW,EAAC,4BAAyB;AAKrF,MAAM,MAAM,YAAY,GAAG,aAAa,GAAG,IAAI,CAAC,kBAAkB,EAAE,mBAAmB,CAAC,CAAC;AAGzF,eAAO,MAAM,KAAK,YAA4B,YAAY,KAAG,QAAQ,WAAW,CA4B/E,CAAC"}

package/dist/api/query.js

@@ -0,0 +1,24 @@
+import { SOURCE_DEFAULTS } from "../sources/index.js";
+import { buildQueryUrl } from "./endpoints.js";
+import { requestWithParameters } from "./request-with-parameters.js";
+export const query = async function (options) {
+    const { apiBaseUrl = SOURCE_DEFAULTS.apiBaseUrl, connectionName, sqlQuery, queryParameters } = options;
+    const urlParameters = { q: sqlQuery };
+    if (queryParameters) {
+        urlParameters.queryParameters = JSON.stringify(queryParameters);
+    }
+    const baseUrl = buildQueryUrl({ apiBaseUrl, connectionName });
+    const headers = { Authorization: `Bearer ${options.accessToken}`, ...options.headers };
+    const errorContext = {
+        requestType: 'SQL',
+        connection: options.connectionName,
+        type: 'query',
+        source: JSON.stringify(urlParameters, undefined, 2)
+    };
+    return await requestWithParameters({
+        baseUrl,
+        parameters: urlParameters,
+        headers,
+        errorContext
+    });
+};

package/dist/api/request-with-parameters.d.ts

@@ -0,0 +1,8 @@
+import type { APIErrorContext } from "./types.js";
+export declare function requestWithParameters<T = any>({ baseUrl, parameters, headers: customHeaders, errorContext }: {
+    baseUrl: string;
+    parameters?: Record<string, string>;
+    headers: Record<string, string>;
+    errorContext: APIErrorContext;
+}): Promise<T>;
+//# sourceMappingURL=request-with-parameters.d.ts.map

package/dist/api/request-with-parameters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-with-parameters.d.ts","sourceRoot":"","sources":["../../src/api/request-with-parameters.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,eAAe,EAAC,mBAAgB;AAU7C,wBAAsB,qBAAqB,CAAC,CAAC,GAAG,GAAG,EAAE,EACnD,OAAO,EACP,UAAU,EACV,OAAO,EAAE,aAAa,EACtB,YAAY,EACb,EAAE;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,YAAY,EAAE,eAAe,CAAC;CAC/B,GAAG,OAAO,CAAC,CAAC,CAAC,CAkCb"}