@deck.gl/carto 8.8.0-alpha.4 → 8.8.0-beta.1

package/src/layers/schema/carto-tile.ts

@@ -0,0 +1,221 @@
+// KeyValueObject ========================================
+interface KeyValueObject {
+  key: string;
+  value: string;
+}
+
+class KeyValueObjectReader {
+  static read(pbf, end?: number): KeyValueObject {
+    return pbf.readFields(KeyValueObjectReader._readField, {key: '', value: ''}, end);
+  }
+  static _readField(this: void, tag: number, obj: KeyValueObject, pbf) {
+    if (tag === 1) obj.key = pbf.readString();
+    else if (tag === 2) obj.value = pbf.readString();
+  }
+}
+
+// Properties ========================================
+
+export interface Properties {
+  data: KeyValueObject[];
+}
+
+class PropertiesReader {
+  static read(pbf, end?: number) {
+    return pbf.readFields(PropertiesReader._readField, {data: []}, end);
+  }
+  static _readField(this: void, tag: number, obj: Properties, pbf) {
+    if (tag === 1) obj.data.push(KeyValueObjectReader.read(pbf, pbf.readVarint() + pbf.pos));
+  }
+}
+
+// Doubles ========================================
+
+interface Doubles {
+  value: Float32Array;
+  size: number;
+}
+
+class DoublesReader {
+  static read(pbf, end?: number): Doubles {
+    // TODO perhaps we can do better and directly map from the source
+    // ArrayBuffer using ArrayBuffer.slice()
+    const {value, size} = pbf.readFields(DoublesReader._readField, {value: [], size: 0}, end);
+    return {value: new Float32Array(value), size};
+  }
+  static _readField(this: void, tag: number, obj, pbf) {
+    if (tag === 1) pbf.readPackedDouble(obj.value);
+    else if (tag === 2) obj.size = pbf.readVarint(true);
+  }
+}
+
+// Ints ========================================
+
+interface Ints {
+  value: Uint32Array;
+  size: number;
+}
+
+class IntsReader {
+  static read(pbf, end?: number): Ints {
+    const {value, size} = pbf.readFields(IntsReader._readField, {value: [], size: 0}, end);
+    return {value: new Uint32Array(value), size};
+  }
+  static _readField(this: void, tag: number, obj, pbf) {
+    if (tag === 1) pbf.readPackedVarint(obj.value);
+    else if (tag === 2) obj.size = pbf.readVarint(true);
+  }
+}
+
+// NumericProp ========================================
+
+interface NumericProp {
+  value: number[];
+}
+
+class NumericPropReader {
+  static read(pbf, end?: number): NumericProp {
+    return pbf.readFields(NumericPropReader._readField, {value: []}, end);
+  }
+  static _readField(this: void, tag: number, obj: NumericProp, pbf) {
+    if (tag === 1) pbf.readPackedDouble(obj.value);
+  }
+}
+
+// NumericPropKeyValue ========================================
+interface NumbericPropKeyValue {
+  key: string;
+  value: NumericProp;
+}
+
+class NumericPropKeyValueReader {
+  static read(pbf, end?: number): NumbericPropKeyValue {
+    return pbf.readFields(NumericPropKeyValueReader._readField, {key: '', value: null}, end);
+  }
+  static _readField(this: void, tag: number, obj: NumbericPropKeyValue, pbf) {
+    if (tag === 1) obj.key = pbf.readString();
+    else if (tag === 2) obj.value = NumericPropReader.read(pbf, pbf.readVarint() + pbf.pos);
+  }
+}
+
+// Points ========================================
+
+interface Points {
+  positions: Doubles;
+  globalFeatureIds: Ints;
+  featureIds: Ints;
+  properties: Properties[];
+  numericProps: Record<string, NumericProp>;
+}
+
+class PointsReader {
+  static read(pbf, end?: number): Points {
+    return pbf.readFields(
+      PointsReader._readField,
+      {positions: null, globalFeatureIds: null, featureIds: null, properties: [], numericProps: {}},
+      end
+    );
+  }
+  static _readField(this: void, tag: number, obj: Points, pbf) {
+    if (tag === 1) obj.positions = DoublesReader.read(pbf, pbf.readVarint() + pbf.pos);
+    else if (tag === 2) obj.globalFeatureIds = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+    else if (tag === 3) obj.featureIds = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+    else if (tag === 4) obj.properties.push(PropertiesReader.read(pbf, pbf.readVarint() + pbf.pos));
+    else if (tag === 5) {
+      const entry = NumericPropKeyValueReader.read(pbf, pbf.readVarint() + pbf.pos);
+      obj.numericProps[entry.key] = entry.value;
+    }
+  }
+}
+
+interface Lines extends Points {
+  pathIndices: Ints;
+}
+// Lines ========================================
+
+class LinesReader {
+  static read(pbf, end?: number): Lines {
+    return pbf.readFields(
+      LinesReader._readField,
+      {
+        positions: null,
+        pathIndices: null,
+        globalFeatureIds: null,
+        featureIds: null,
+        properties: [],
+        numericProps: {}
+      },
+      end
+    );
+  }
+  static _readField(this: void, tag: number, obj: Lines, pbf) {
+    if (tag === 1) obj.positions = DoublesReader.read(pbf, pbf.readVarint() + pbf.pos);
+    else if (tag === 2) obj.pathIndices = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+    else if (tag === 3) obj.globalFeatureIds = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+    else if (tag === 4) obj.featureIds = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+    else if (tag === 5) obj.properties.push(PropertiesReader.read(pbf, pbf.readVarint() + pbf.pos));
+    else if (tag === 6) {
+      const entry = NumericPropKeyValueReader.read(pbf, pbf.readVarint() + pbf.pos);
+      obj.numericProps[entry.key] = entry.value;
+    }
+  }
+}
+// Polygons ========================================
+
+interface Polygons extends Points {
+  polygonIndices: Ints;
+  primitivePolygonIndices: Ints;
+  triangles: Ints;
+}
+
+class PolygonsReader {
+  static read(pbf, end?: number): Polygons {
+    return pbf.readFields(
+      PolygonsReader._readField,
+      {
+        positions: null,
+        polygonIndices: null,
+        globalFeatureIds: null,
+        featureIds: null,
+        primitivePolygonIndices: null,
+        triangles: null,
+        properties: [],
+        numericProps: {}
+      },
+      end
+    );
+  }
+  static _readField(this: void, tag: number, obj: Polygons, pbf) {
+    if (tag === 1) obj.positions = DoublesReader.read(pbf, pbf.readVarint() + pbf.pos);
+    else if (tag === 2) obj.polygonIndices = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+    else if (tag === 3) obj.globalFeatureIds = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+    else if (tag === 4) obj.featureIds = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+    else if (tag === 5)
+      obj.primitivePolygonIndices = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+    else if (tag === 6) obj.triangles = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
+    else if (tag === 7) obj.properties.push(PropertiesReader.read(pbf, pbf.readVarint() + pbf.pos));
+    else if (tag === 8) {
+      const entry = NumericPropKeyValueReader.read(pbf, pbf.readVarint() + pbf.pos);
+      obj.numericProps[entry.key] = entry.value;
+    }
+  }
+}
+
+// Tile ========================================
+
+export interface Tile {
+  points: Points;
+  lines: Lines;
+  polygons: Polygons;
+}
+
+export class TileReader {
+  static read(pbf, end?: number): Tile {
+    return pbf.readFields(TileReader._readField, {points: null, lines: null, polygons: null}, end);
+  }
+  static _readField(this: void, tag: number, obj: Tile, pbf) {
+    if (tag === 1) obj.points = PointsReader.read(pbf, pbf.readVarint() + pbf.pos);
+    else if (tag === 2) obj.lines = LinesReader.read(pbf, pbf.readVarint() + pbf.pos);
+    else if (tag === 3) obj.polygons = PolygonsReader.read(pbf, pbf.readVarint() + pbf.pos);
+  }
+}

package/src/layers/{spatial-index-tile-layer.js → spatial-index-tile-layer.ts}

@@ -1,11 +1,14 @@
-import {TileLayer} from '@deck.gl/geo-layers';
+import {PickingInfo} from '@deck.gl/core';
+import {TileLayer, _Tile2DHeader as Tile2DHeader} from '@deck.gl/geo-layers';
 
-function isFeatureIdDefined(value) {
+function isFeatureIdDefined(value: unknown): boolean {
   return value !== undefined && value !== null && value !== '';
 }
 
-export default class SpatialIndexTileLayer extends TileLayer {
-  _updateAutoHighlight(info) {
+export default class SpatialIndexTileLayer<ExtraProps = {}> extends TileLayer<any, ExtraProps> {
+  static layerName = 'SpatialIndexTileLayer';
+
+  protected _updateAutoHighlight(info: PickingInfo): void {
     const {hoveredFeatureId} = this.state;
     const hoveredFeature = info.object;
     let newHoveredFeatureId;
@@ -27,14 +30,14 @@ export default class SpatialIndexTileLayer extends TileLayer {
     }
   }
 
-  getSubLayerPropsByTile(tile) {
+  getSubLayerPropsByTile(tile: Tile2DHeader) {
     return {
       highlightedObjectIndex: this.getHighlightedObjectIndex(tile),
       highlightColor: this.state.highlightColor
     };
   }
 
-  getHighlightedObjectIndex(tile) {
+  getHighlightedObjectIndex(tile: Tile2DHeader) {
     const {hoveredFeatureId} = this.state;
     const data = tile.content;
 

package/typed/api/index.d.ts

@@ -0,0 +1,4 @@
+export { FORMATS, TILE_FORMATS, MAP_TYPES, API_VERSIONS } from './maps-api-common';
+export { getDataV2, CONNECTIONS } from './maps-client';
+export { fetchLayerData, fetchMap, getData, mapInstantiation } from './maps-v3-client';
+//# sourceMappingURL=index.d.ts.map

package/typed/api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,YAAY,EAAC,MAAM,mBAAmB,CAAC;AACjF,OAAO,EAAC,SAAS,EAAE,WAAW,EAAC,MAAM,eAAe,CAAC;AACrD,OAAO,EAAC,cAAc,EAAE,QAAQ,EAAE,OAAO,EAAE,gBAAgB,EAAC,MAAM,kBAAkB,CAAC"}

package/typed/api/index.js

@@ -0,0 +1,3 @@
+export { FORMATS, TILE_FORMATS, MAP_TYPES, API_VERSIONS } from './maps-api-common';
+export { getDataV2, CONNECTIONS } from './maps-client';
+export { fetchLayerData, fetchMap, getData, mapInstantiation } from './maps-v3-client';

package/typed/api/layer-map.d.ts

@@ -0,0 +1,54 @@
+import { scaleLinear, scaleOrdinal, scaleLog, scalePoint, scaleQuantile, scaleQuantize, scaleSqrt, scaleThreshold } from 'd3-scale';
+import { Layer, _ConstructorOf as ConstructorOf } from '@deck.gl/core/typed';
+declare const SCALE_FUNCS: {
+    linear: typeof scaleLinear;
+    ordinal: typeof scaleOrdinal;
+    log: typeof scaleLog;
+    point: typeof scalePoint;
+    quantile: typeof scaleQuantile;
+    quantize: typeof scaleQuantize;
+    sqrt: typeof scaleSqrt;
+    custom: typeof scaleThreshold;
+};
+export declare type SCALE_TYPE = keyof typeof SCALE_FUNCS;
+export declare const AGGREGATION: {
+    average: string;
+    maximum: string;
+    minimum: string;
+    sum: string;
+};
+export declare const OPACITY_MAP: {
+    getFillColor: string;
+    getLineColor: string;
+    getTextColor: string;
+};
+export declare function getLayer(type: string, config: any, dataset: any): {
+    Layer: ConstructorOf<Layer>;
+    propMap: any;
+    defaultProps: any;
+};
+declare function domainFromValues(values: any, scaleType: SCALE_TYPE): any;
+export declare function opacityToAlpha(opacity: any): number;
+export declare function getColorValueAccessor({ name }: {
+    name: any;
+}, colorAggregation: any, data: any): any;
+export declare function getColorAccessor({ name }: {
+    name: any;
+}, scaleType: SCALE_TYPE, { colors, colorMap }: {
+    colors: any;
+    colorMap: any;
+}, opacity: number | undefined, data: any): any;
+export declare function getSizeAccessor({ name }: {
+    name: any;
+}, scaleType: SCALE_TYPE, range: Iterable<Range>, data: any): any;
+export declare function getTextAccessor({ name, type }: {
+    name: any;
+    type: any;
+}, data: any): any;
+export declare function getTextPixelOffsetAccessor({ alignment, anchor, size }: {
+    alignment: any;
+    anchor: any;
+    size: any;
+}, radius: any): number[] | ((d: any) => number[]);
+export { domainFromValues as _domainFromValues };
+//# sourceMappingURL=layer-map.d.ts.map

package/typed/api/layer-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layer-map.d.ts","sourceRoot":"","sources":["../../src/api/layer-map.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,WAAW,EACX,YAAY,EACZ,QAAQ,EACR,UAAU,EACV,aAAa,EACb,aAAa,EACb,SAAS,EACT,cAAc,EACf,MAAM,UAAU,CAAC;AAIlB,OAAO,EAAC,KAAK,EAAE,cAAc,IAAI,aAAa,EAAC,MAAM,eAAe,CAAC;AASrE,QAAA,MAAM,WAAW;;;;;;;;;CAShB,CAAC;AACF,oBAAY,UAAU,GAAG,MAAM,OAAO,WAAW,CAAC;AAIlD,eAAO,MAAM,WAAW;;;;;CAKvB,CAAC;AAEF,eAAO,MAAM,WAAW;;;;CAIvB,CAAC;AA2DF,wBAAgB,QAAQ,CACtB,IAAI,EAAE,MAAM,EACZ,MAAM,KAAA,EACN,OAAO,KAAA,GACN;IAAC,KAAK,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC;IAAC,OAAO,EAAE,GAAG,CAAC;IAAC,YAAY,EAAE,GAAG,CAAA;CAAC,CAmDhE;AAkCD,iBAAS,gBAAgB,CAAC,MAAM,KAAA,EAAE,SAAS,EAAE,UAAU,OActD;AA8BD,wBAAgB,cAAc,CAAC,OAAO,KAAA,UAErC;AAED,wBAAgB,qBAAqB,CAAC,EAAC,IAAI,EAAC;;CAAA,EAAE,gBAAgB,KAAA,EAAE,IAAI,EAAE,GAAG,OAIxE;AAED,wBAAgB,gBAAgB,CAC9B,EAAC,IAAI,EAAC;;CAAA,EACN,SAAS,EAAE,UAAU,EACrB,EAAC,MAAM,EAAE,QAAQ,EAAC;;;CAAA,EAClB,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,IAAI,EAAE,GAAG,OA+BV;AAED,wBAAgB,eAAe,CAAC,EAAC,IAAI,EAAC;;CAAA,EAAE,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,GAAG,OAS/F;AAUD,wBAAgB,eAAe,CAAC,EAAC,IAAI,EAAE,IAAI,EAAC;;;CAAA,EAAE,IAAI,KAAA,OAMjD;AAED,wBAAgB,0BAA0B,CAAC,EAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAC;;;;CAAA,EAAE,MAAM,KAAA,qCAa3E;AAED,OAAO,EAAC,gBAAgB,IAAI,iBAAiB,EAAC,CAAC"}

package/typed/api/layer-map.js

@@ -0,0 +1,264 @@
+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, MVTLayer } from '@deck.gl/geo-layers';
+import CartoTileLayer from '../layers/carto-tile-layer';
+import { TILE_FORMATS } from './maps-api-common';
+import { assert } from '../utils';
+const SCALE_FUNCS = {
+    linear: scaleLinear,
+    ordinal: scaleOrdinal,
+    log: scaleLog,
+    point: scalePoint,
+    quantile: scaleQuantile,
+    quantize: scaleQuantize,
+    sqrt: scaleSqrt,
+    custom: scaleThreshold
+};
+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 -> Deck.gl
+const sharedPropMap = {
+    color: 'getFillColor',
+    isVisible: 'visible',
+    label: 'cartoLabel',
+    textLabel: {
+        alignment: 'getTextAlignmentBaseline',
+        anchor: 'getTextAnchor',
+        color: 'getTextColor',
+        size: 'getTextSize'
+    },
+    visConfig: {
+        enable3d: 'extruded',
+        elevationScale: 'elevationScale',
+        filled: 'filled',
+        strokeColor: 'getLineColor',
+        stroked: 'stroked',
+        thickness: 'getLineWidth',
+        radius: 'getPointRadius',
+        wireframe: 'wireframe'
+    }
+};
+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) {
+    if (type === 'mvt' || type === 'tileset') {
+        return getTileLayer(dataset);
+    }
+    const geoColumn = dataset?.geoColumn;
+    const getPosition = d => d[geoColumn].coordinates;
+    const hexagonId = config.columns?.hex_id;
+    const layerTypeDefs = {
+        point: {
+            Layer: GeoJsonLayer,
+            propMap: { 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(sharedPropMap, layer.propMap),
+        defaultProps: { ...defaultProps, ...layer.defaultProps }
+    };
+}
+function getTileLayer(dataset) {
+    const { data: { tiles: [tileUrl] } } = dataset;
+    /* global URL */
+    const formatTiles = new URL(tileUrl).searchParams.get('formatTiles') || TILE_FORMATS.MVT;
+    return {
+        Layer: formatTiles === TILE_FORMATS.MVT ? MVTLayer : CartoTileLayer,
+        propMap: sharedPropMap,
+        defaultProps: {
+            ...defaultProps,
+            uniqueIdProperty: 'geoid',
+            formatTiles
+        }
+    };
+}
+function domainFromAttribute(attribute, scaleType) {
+    if (scaleType === 'ordinal' || scaleType === 'point') {
+        return attribute.categories.map(c => c.category).filter(c => c !== undefined && c !== null);
+    }
+    let { min } = attribute;
+    if (scaleType === 'log' && min === 0) {
+        min = 1e-5;
+    }
+    return [min, attribute.max];
+}
+function domainFromValues(values, scaleType) {
+    if (scaleType === 'ordinal') {
+        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) {
+    if (data.tilestats) {
+        // Tileset data type
+        const { attributes } = data.tilestats.layers[0];
+        const attribute = attributes.find(a => a.attribute === name);
+        return domainFromAttribute(attribute, scaleType);
+    }
+    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 ({ properties }) => {
+            return accessor(properties);
+        };
+    }
+    return accessor;
+}
+export function opacityToAlpha(opacity) {
+    return opacity !== undefined ? Math.round(255 * Math.pow(opacity, 1 / 2.2)) : 255;
+}
+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 }, scaleType, { colors, colorMap }, opacity, data) {
+    const scale = SCALE_FUNCS[scaleType]();
+    let domain = [];
+    let scaleColor = [];
+    if (Array.isArray(colorMap)) {
+        colorMap.forEach(([value, color]) => {
+            domain.push(value);
+            scaleColor.push(color);
+        });
+    }
+    else {
+        domain = calculateDomain(data, name, scaleType);
+        scaleColor = colors;
+    }
+    if (scaleType === 'ordinal') {
+        domain = domain.slice(0, scaleColor.length);
+    }
+    scale.domain(domain);
+    scale.range(scaleColor);
+    scale.unknown(UNKNOWN_COLOR);
+    const alpha = opacityToAlpha(opacity);
+    const accessor = properties => {
+        const propertyValue = properties[name];
+        const { r, g, b } = rgb(scale(propertyValue));
+        return [r, g, b, propertyValue === null ? 0 : alpha];
+    };
+    return normalizeAccessor(accessor, data);
+}
+export function getSizeAccessor({ name }, scaleType, range, data) {
+    const scale = SCALE_FUNCS[scaleType]();
+    scale.domain(calculateDomain(data, name, scaleType));
+    scale.range(range);
+    const accessor = properties => {
+        return scale(properties[name]);
+    };
+    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 function getTextPixelOffsetAccessor({ alignment, anchor, size }, radius) {
+    const padding = 20;
+    const signX = anchor === 'middle' ? 0 : anchor === 'start' ? 1 : -1;
+    const signY = alignment === 'center' ? 0 : alignment === 'bottom' ? 1 : -1;
+    const sizeOffset = alignment === 'center' ? 0 : size;
+    const calculateOffset = r => [signX * (r + padding), signY * (r + padding + sizeOffset)];
+    return typeof radius === 'function'
+        ? d => {
+            return calculateOffset(radius(d));
+        }
+        : calculateOffset(radius);
+}
+export { domainFromValues as _domainFromValues };

package/typed/api/maps-api-common.d.ts

@@ -0,0 +1,65 @@
+export declare const DEFAULT_USER_COMPONENT_IN_URL = "{user}";
+export declare const DEFAULT_REGION_COMPONENT_IN_URL = "{region}";
+export declare type ValuesOf<T extends {}> = T[keyof T];
+export declare const API_VERSIONS: {
+    readonly V1: "v1";
+    readonly V2: "v2";
+    readonly V3: "v3";
+};
+export declare type ApiVersion = ValuesOf<typeof API_VERSIONS>;
+export declare const DEFAULT_MAPS_URL_FORMAT: {
+    readonly v1: "https://{user}.carto.com/api/v1/map";
+    readonly v2: "https://maps-api-v2.{region}.carto.com/user/{user}";
+};
+export declare const MAP_TYPES: {
+    readonly QUERY: "query";
+    readonly TABLE: "table";
+    readonly TILESET: "tileset";
+};
+export declare type MapType = ValuesOf<typeof MAP_TYPES>;
+export declare const COLUMNS_SUPPORT: MapType[];
+export declare const GEO_COLUMN_SUPPORT: MapType[];
+export declare const FORMATS: {
+    readonly GEOJSON: "geojson";
+    readonly NDJSON: "ndjson";
+    readonly TILEJSON: "tilejson";
+    readonly JSON: "json";
+};
+export declare type Format = ValuesOf<typeof FORMATS>;
+export declare const TILE_FORMATS: {
+    readonly MVT: "mvt";
+    readonly JSON: "json";
+    readonly GEOJSON: "geojson";
+    readonly BINARY: "binary";
+};
+export declare type TileFormat = ValuesOf<typeof TILE_FORMATS>;
+export declare enum SchemaFieldType {
+    Number = "number",
+    Bigint = "bigint",
+    String = "string",
+    Geometry = "geometry",
+    Timestamp = "timestamp",
+    Object = "object",
+    Boolean = "boolean",
+    Variant = "variant",
+    Unknown = "unknown"
+}
+export interface SchemaField {
+    name: string;
+    type: SchemaFieldType;
+}
+export interface MapInstantiation extends MapInstantiationFormats {
+    nrows: number;
+    size?: number;
+    schema: SchemaField[];
+}
+declare type MapInstantiationFormats = Record<Format, {
+    url: string[];
+    error?: any;
+}>;
+/**
+ * Simple encode parameter
+ */
+export declare function encodeParameter(name: string, value: string | boolean | number): string;
+export {};
+//# sourceMappingURL=maps-api-common.d.ts.map

package/typed/api/maps-api-common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maps-api-common.d.ts","sourceRoot":"","sources":["../../src/api/maps-api-common.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,6BAA6B,WAAW,CAAC;AACtD,eAAO,MAAM,+BAA+B,aAAa,CAAC;AAE1D,oBAAY,QAAQ,CAAC,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AAChD,eAAO,MAAM,YAAY;;;;CAIf,CAAC;AACX,oBAAY,UAAU,GAAG,QAAQ,CAAC,OAAO,YAAY,CAAC,CAAC;AAEvD,eAAO,MAAM,uBAAuB;;;CAG1B,CAAC;AAEX,eAAO,MAAM,SAAS;;;;CAIZ,CAAC;AACX,oBAAY,OAAO,GAAG,QAAQ,CAAC,OAAO,SAAS,CAAC,CAAC;AACjD,eAAO,MAAM,eAAe,EAAE,OAAO,EAAsB,CAAC;AAC5D,eAAO,MAAM,kBAAkB,EAAE,OAAO,EAAuC,CAAC;AAGhF,eAAO,MAAM,OAAO;;;;;CAKV,CAAC;AACX,oBAAY,MAAM,GAAG,QAAQ,CAAC,OAAO,OAAO,CAAC,CAAC;AAG9C,eAAO,MAAM,YAAY;;;;;CAKf,CAAC;AACX,oBAAY,UAAU,GAAG,QAAQ,CAAC,OAAO,YAAY,CAAC,CAAC;AAEvD,oBAAY,eAAe;IACzB,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,QAAQ,aAAa;IACrB,SAAS,cAAc;IACvB,MAAM,WAAW;IACjB,OAAO,YAAY;IACnB,OAAO,YAAY;IACnB,OAAO,YAAY;CACpB;AACD,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,eAAe,CAAC;CACvB;AAED,MAAM,WAAW,gBAAiB,SAAQ,uBAAuB;IAC/D,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,WAAW,EAAE,CAAC;CACvB;AAED,aAAK,uBAAuB,GAAG,MAAM,CACnC,MAAM,EACN;IACE,GAAG,EAAE,MAAM,EAAE,CAAC;IACd,KAAK,CAAC,EAAE,GAAG,CAAC;CACb,CACF,CAAC;AAEF;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAEtF"}