@carto/api-client 0.5.15-alpha.raster-1 → 0.5.15-alpha.raster-3

package/build/api-client.js

@@ -9157,6 +9157,37 @@ function formatDate(value) {
 function formatTimestamp(value) {
   return String(Math.floor(new Date(value).getTime() / 1e3));
 }
+function roundedPow10(exp) {
+  const raw = Math.pow(10, exp);
+  if (exp < 0) {
+    const shift = Math.pow(10, -exp);
+    return Math.round(raw * shift) / shift;
+  }
+  return raw;
+}
+function getLog10ScaleSteps({
+  min: min2,
+  max: max2,
+  steps
+}) {
+  if (min2 === 0) {
+    if (max2 === Infinity) {
+      return [...Array(steps - 1)].map((_v, i) => roundedPow10(i + 1));
+    }
+    const maxLog = Math.log10(max2);
+    const endExponent = Math.ceil(maxLog);
+    const startExponent = endExponent - steps + 1;
+    return [...Array(steps - 1)].map(
+      (_v, i) => roundedPow10(startExponent + i)
+    );
+  } else {
+    const minLog = Math.log10(min2);
+    const startExponent = Math.ceil(minLog) === minLog ? minLog + 1 : Math.ceil(minLog);
+    return [...Array(steps - 1)].map(
+      (_v, i) => roundedPow10(startExponent + i)
+    );
+  }
+}
 
 // src/fetch-map/layer-map.ts
 var SCALE_FUNCS = {
@@ -9173,7 +9204,19 @@ var SCALE_FUNCS = {
 function identity2(v2) {
   return v2;
 }
+var hexToRGB = (c) => {
+  const { r, g, b } = rgb(c);
+  return [r, g, b];
+};
+var rgbToHex = (c) => {
+  const [r, g, b] = c;
+  const rStr = r.toString(16).padStart(2, "0");
+  const gStr = g.toString(16).padStart(2, "0");
+  const bStr = b.toString(16).padStart(2, "0");
+  return `#${rStr}${gStr}${bStr}`.toUpperCase();
+};
 var UNKNOWN_COLOR = "#868d91";
+var UNKNOWN_COLOR_RGB = hexToRGB(UNKNOWN_COLOR);
 var OPACITY_MAP = {
   getFillColor: "opacity",
   getLineColor: "strokeOpacity",
@@ -9354,7 +9397,7 @@ function findAccessorKey(keys, properties) {
   return keys;
 }
 function getColorAccessor({ name, colorColumn }, scaleType, { aggregation, range }, opacity, data) {
-  const scale2 = calculateLayerScale(
+  const { scale: scale2, domain } = calculateLayerScale(
     colorColumn || name,
     scaleType,
     range,
@@ -9367,30 +9410,54 @@ function getColorAccessor({ name, colorColumn }, scaleType, { aggregation, range
       accessorKeys = findAccessorKey(accessorKeys, properties);
     }
     const propertyValue = properties[accessorKeys[0]];
-    const { r, g, b } = rgb(scale2(propertyValue));
+    const [r, g, b] = scale2(propertyValue);
     return [r, g, b, propertyValue === null ? 0 : alpha];
   };
-  return { accessor: normalizeAccessor(accessor, data), scale: scale2 };
+  return {
+    accessor: normalizeAccessor(accessor, data),
+    scaleDomain: scale2.domain(),
+    domain,
+    range: scale2.range().map(rgbToHex)
+  };
 }
 function calculateLayerScale(name, scaleType, range, data) {
   let domain = [];
+  let scaleDomain;
   let scaleColor = [];
-  if (scaleType !== "identity") {
-    const { colorMap, colors } = range;
-    if (Array.isArray(colorMap)) {
+  const { colors } = range;
+  if (scaleType === "custom") {
+    if (range.uiCustomScaleType === "logarithmic") {
+      domain = calculateDomain(data, name, scaleType, colors.length);
+      const [min2, max2] = domain;
+      scaleDomain = getLog10ScaleSteps({
+        min: min2,
+        max: max2,
+        steps: colors.length
+      });
+      scaleColor = colors;
+    } else if (range.colorMap) {
+      const { colorMap } = range;
       colorMap.forEach(([value, color2]) => {
         domain.push(value);
         scaleColor.push(color2);
       });
-    } else {
-      domain = calculateDomain(data, name, scaleType, colors.length);
-      scaleColor = colors;
     }
+  } else if (scaleType !== "identity") {
+    domain = calculateDomain(data, name, scaleType, colors.length);
+    scaleColor = colors;
     if (scaleType === "ordinal") {
       domain = domain.slice(0, scaleColor.length);
     }
   }
-  return createColorScale(scaleType, domain, scaleColor, UNKNOWN_COLOR);
+  return {
+    scale: createColorScale(
+      scaleType,
+      scaleDomain || domain,
+      scaleColor.map(hexToRGB),
+      UNKNOWN_COLOR_RGB
+    ),
+    domain
+  };
 }
 function createColorScale(scaleType, domain, range, unknown) {
   const scale2 = SCALE_FUNCS[scaleType]();
@@ -9446,9 +9513,13 @@ function negateAccessor(accessor) {
 }
 function getSizeAccessor({ name }, scaleType, aggregation, range, data) {
   const scale2 = scaleType ? SCALE_FUNCS[scaleType]() : identity2;
-  if (scaleType) {
+  let domain = [];
+  if (scaleType && range) {
     if (aggregation !== AggregationTypes.Count) {
-      scale2.domain(calculateDomain(data, name, scaleType));
+      domain = calculateDomain(data, name, scaleType);
+      scale2.domain(domain);
+    } else {
+      domain = scale2.domain();
     }
     scale2.range(range);
   }
@@ -9460,7 +9531,12 @@ function getSizeAccessor({ name }, scaleType, aggregation, range, data) {
     const propertyValue = properties[accessorKeys[0]];
     return scale2(propertyValue);
   };
-  return { accessor: normalizeAccessor(accessor, data), scale: scale2 };
+  return {
+    accessor: normalizeAccessor(accessor, data),
+    domain,
+    scaleDomain: domain,
+    range
+  };
 }
 var FORMATS = {
   date: formatDate,
@@ -9766,10 +9842,11 @@ function domainFromRasterMetadataBand(band, scaleType, colorRange) {
   }
   if (scaleType === "custom") {
     if (colorRange.uiCustomScaleType === "logarithmic") {
-      if (colorRange.colorMap) {
-        return colorRange.colorMap?.map(([value]) => value) || [];
-      }
-      return [band.stats.min, band.stats.max];
+      return getLog10ScaleSteps({
+        min: band.stats.min,
+        max: band.stats.max,
+        steps: colorRange.colors.length
+      });
     } else {
       return colorRange.colorMap?.map(([value]) => value) || [];
     }
@@ -9804,7 +9881,7 @@ function getRasterTileLayerStylePropsScaledBand({
   const scaleFun = createColorScale(
     scaleType,
     domain,
-    colorRange.colors.map(hexToRGB),
+    colorRange.colors.map(hexToRGB2),
     UNKNOWN_COLOR2
   );
   const bandColorScaleDataTransform = createBandColorScaleDataTransform({
@@ -9872,7 +9949,7 @@ function bufferSetRgba(target, index, r, g, b, a) {
   target[index + 2] = b;
   target[index + 3] = a;
 }
-function hexToRGB(hexColor) {
+function hexToRGB2(hexColor) {
   const r = parseInt(hexColor.slice(1, 3), 16);
   const g = parseInt(hexColor.slice(3, 5), 16);
   const b = parseInt(hexColor.slice(5, 7), 16);
@@ -10013,24 +10090,7 @@ function createStyleProps(config2, mapping) {
   result.highlightColor = config2.visConfig.enable3d ? [255, 255, 255, 60] : [252, 242, 26, 255];
   return result;
 }
-function domainAndRangeFromScale(scale2) {
-  return {
-    domain: scale2.domain(),
-    range: scale2.range()
-  };
-}
 function createChannelProps(id, layerType, config2, visualChannels, data, dataset) {
-  const {
-    colorField,
-    colorScale,
-    radiusField,
-    radiusScale,
-    strokeColorField,
-    strokeColorScale,
-    sizeField: strokeWidthField,
-    sizeScale: strokeWidthScale,
-    weightField
-  } = visualChannels;
   if (layerType === "raster") {
     const rasterMetadata = data.raster_metadata;
     if (!rasterMetadata) {
@@ -10048,6 +10108,7 @@ function createChannelProps(id, layerType, config2, visualChannels, data, datase
           visualChannels
         }),
         scales: {}
+        // TODO
       };
     } else {
       return {
@@ -10057,40 +10118,35 @@ function createChannelProps(id, layerType, config2, visualChannels, data, datase
           rasterMetadata
         }),
         scales: {
-          ...colorField && {
-            fillColor: {
-              field: colorField,
-              type: "ordinal",
-              domain: [],
-              range: []
-            }
-          }
+          // TODO
         }
       };
     }
   }
-  const { heightField, heightScale } = visualChannels;
   const { textLabel, visConfig } = config2;
   const result = {};
   const updateTriggers = {};
   const scales = {};
-  if (colorField) {
-    const { colorAggregation: aggregation, colorRange: range } = visConfig;
-    const { accessor, scale: scale2 } = getColorAccessor(
-      colorField,
-      colorScale,
-      { aggregation, range },
-      visConfig.opacity,
-      data
-    );
-    result.getFillColor = accessor;
-    scales.fillColor = updateTriggers.getFillColor = {
-      field: colorField,
-      type: colorScale,
-      ...domainAndRangeFromScale(scale2)
-    };
-  } else if (visConfig.filled) {
-    scales.fillColor = {};
+  {
+    const { colorField, colorScale } = visualChannels;
+    const { colorRange, colorAggregation } = visConfig;
+    if (colorField && colorScale && colorRange) {
+      const { accessor, ...scaleProps } = getColorAccessor(
+        colorField,
+        colorScale,
+        { aggregation: colorAggregation, range: colorRange },
+        visConfig.opacity,
+        data
+      );
+      result.getFillColor = accessor;
+      scales.fillColor = updateTriggers.getFillColor = {
+        field: colorField,
+        type: colorScale,
+        ...scaleProps
+      };
+    } else {
+      scales.fillColor = {};
+    }
   }
   if (layerType === "clusterTile") {
     const aggregationExpAlias = getDefaultAggregationExpColumnAliasForLayerType(
@@ -10143,82 +10199,102 @@ function createChannelProps(id, layerType, config2, visualChannels, data, datase
       radiusRange: visConfig.radiusRange
     };
   }
-  if (radiusField) {
-    const { accessor, scale: scale2 } = getSizeAccessor(
-      radiusField,
-      radiusScale,
-      visConfig.sizeAggregation,
-      visConfig.radiusRange || visConfig.sizeRange,
-      data
-    );
-    result.getPointRadius = accessor;
-    scales.pointRadius = updateTriggers.getPointRadius = {
-      field: radiusField,
-      type: radiusScale || "identity",
-      ...domainAndRangeFromScale(scale2)
-    };
+  {
+    const radiusRange = visConfig.radiusRange;
+    const { radiusField, radiusScale } = visualChannels;
+    if (radiusField && radiusRange && radiusScale) {
+      const { accessor, ...scaleProps } = getSizeAccessor(
+        radiusField,
+        radiusScale,
+        visConfig.sizeAggregation,
+        radiusRange,
+        data
+      );
+      result.getPointRadius = accessor;
+      scales.pointRadius = updateTriggers.getPointRadius = {
+        field: radiusField,
+        type: radiusScale,
+        ...scaleProps
+      };
+    }
   }
-  if (strokeColorField) {
-    const opacity = visConfig.strokeOpacity !== void 0 ? visConfig.strokeOpacity : 1;
-    const { strokeColorAggregation: aggregation, strokeColorRange: range } = visConfig;
-    const { accessor, scale: scale2 } = getColorAccessor(
-      strokeColorField,
-      strokeColorScale,
-      { aggregation, range },
-      opacity,
-      data
-    );
-    result.getLineColor = accessor;
-    scales.lineColor = updateTriggers.getLineColor = {
-      field: strokeColorField,
-      type: strokeColorScale,
-      ...domainAndRangeFromScale(scale2)
-    };
+  {
+    const strokeColorRange = visConfig.strokeColorRange;
+    const { strokeColorScale, strokeColorField } = visualChannels;
+    if (strokeColorField && strokeColorRange && strokeColorScale) {
+      const { strokeColorAggregation: aggregation } = visConfig;
+      const opacity = visConfig.strokeOpacity !== void 0 ? visConfig.strokeOpacity : 1;
+      const { accessor, ...scaleProps } = getColorAccessor(
+        strokeColorField,
+        strokeColorScale,
+        { aggregation, range: strokeColorRange },
+        opacity,
+        data
+      );
+      result.getLineColor = accessor;
+      scales.lineColor = updateTriggers.getLineColor = {
+        field: strokeColorField,
+        type: strokeColorScale,
+        ...scaleProps
+      };
+    }
   }
-  if (strokeWidthField) {
-    const { accessor, scale: scale2 } = getSizeAccessor(
-      strokeWidthField,
-      strokeWidthScale,
-      visConfig.sizeAggregation,
-      visConfig.sizeRange,
-      data
-    );
-    result.getLineWidth = accessor;
-    scales.lineWidth = updateTriggers.getLineWidth = {
-      field: strokeWidthField,
-      type: strokeWidthScale || "identity",
-      ...domainAndRangeFromScale(scale2)
-    };
+  {
+    const { sizeField: strokeWidthField, sizeScale: strokeWidthScale } = visualChannels;
+    const { sizeRange, sizeAggregation } = visConfig;
+    if (strokeWidthField && sizeRange) {
+      const { accessor, ...scaleProps } = getSizeAccessor(
+        strokeWidthField,
+        strokeWidthScale,
+        sizeAggregation,
+        sizeRange,
+        data
+      );
+      result.getLineWidth = accessor;
+      scales.lineWidth = updateTriggers.getLineWidth = {
+        field: strokeWidthField,
+        type: strokeWidthScale || "identity",
+        ...scaleProps
+      };
+    }
   }
-  if (heightField && visConfig.enable3d) {
-    const { accessor, scale: scale2 } = getSizeAccessor(
-      heightField,
-      heightScale,
-      visConfig.heightAggregation,
-      visConfig.heightRange || visConfig.sizeRange,
-      data
-    );
-    result.getElevation = accessor;
-    scales.elevation = updateTriggers.getElevation = {
-      field: heightField,
-      type: heightScale || "identity",
-      ...domainAndRangeFromScale(scale2)
-    };
+  {
+    const { enable3d, heightRange } = visConfig;
+    const { heightField, heightScale } = visualChannels;
+    if (heightField && heightRange && enable3d) {
+      const { accessor, ...scaleProps } = getSizeAccessor(
+        heightField,
+        heightScale,
+        visConfig.heightAggregation,
+        heightRange,
+        data
+      );
+      result.getElevation = accessor;
+      scales.elevation = updateTriggers.getElevation = {
+        field: heightField,
+        type: heightScale || "identity",
+        ...scaleProps
+      };
+    }
   }
-  if (weightField) {
-    const { accessor, scale: scale2 } = getSizeAccessor(
-      weightField,
-      void 0,
-      visConfig.weightAggregation,
-      void 0,
-      data
-    );
-    result.getWeight = accessor;
-    scales.weight = updateTriggers.getWeight = {
-      field: weightField,
-      type: "identity",
-      ...domainAndRangeFromScale(scale2)
-    };
+  {
+    const { weightField } = visualChannels;
+    const { weightAggregation } = visConfig;
+    if (weightField && weightAggregation) {
+      const { accessor, ...scaleProps } = getSizeAccessor(
+        weightField,
+        void 0,
+        weightAggregation,
+        void 0,
+        data
+      );
+      result.getWeight = accessor;
+      scales.weight = updateTriggers.getWeight = {
+        field: weightField,
+        type: "identity",
+        ...scaleProps
+      };
+    }
   }
   if (visConfig.customMarkers) {
     const maxIconSize = getMaxMarkerSize(visConfig, visualChannels);
@@ -10977,6 +11053,7 @@ export {
   domainFromValues as _domainFromValues,
   evaluateVecExpr as _evaluateVecExpr,
   _getHexagonResolution,
+  getLog10ScaleSteps as _getLog10ScaleSteps,
   getRasterTileLayerStyleProps as _getRasterTileLayerStyleProps,
   validateVecExprSyntax as _validateVecExprSyntax,
   addFilter,