@carto/api-client 0.5.13 → 0.5.15-alpha.raster-0

package/build/api-client.js

@@ -94,11 +94,11 @@ var FilterType = /* @__PURE__ */ ((FilterType2) => {
   FilterType2["STRING_SEARCH"] = "stringSearch";
   return FilterType2;
 })(FilterType || {});
-var ApiVersion = /* @__PURE__ */ ((ApiVersion3) => {
-  ApiVersion3["V1"] = "v1";
-  ApiVersion3["V2"] = "v2";
-  ApiVersion3["V3"] = "v3";
-  return ApiVersion3;
+var ApiVersion = /* @__PURE__ */ ((ApiVersion2) => {
+  ApiVersion2["V1"] = "v1";
+  ApiVersion2["V2"] = "v2";
+  ApiVersion2["V3"] = "v3";
+  return ApiVersion2;
 })(ApiVersion || {});
 var DEFAULT_API_BASE_URL = "https://gcp-us-east1.api.carto.com";
 var TileFormat = /* @__PURE__ */ ((TileFormat2) => {
@@ -6593,6 +6593,48 @@ var WidgetRemoteSource = class extends WidgetSource {
       categories: res.metadata?.categories
     }));
   }
+  /** @experimental */
+  async getExtent(options = {}) {
+    const { signal, filters = this.props.filters, filterOwner } = options;
+    const {
+      type,
+      data,
+      apiBaseUrl,
+      apiVersion,
+      connectionName,
+      spatialDataColumn,
+      spatialDataType,
+      queryParameters
+    } = this.getModelSource(filters, filterOwner);
+    assert2(apiVersion === "v3" /* V3 */, "Stats API requires CARTO 3+");
+    let url;
+    const parameters = { filters, spatialDataType };
+    if (type === "query") {
+      url = `${apiBaseUrl}/${apiVersion}/stats/${connectionName}/${spatialDataColumn}`;
+      parameters.q = data;
+      parameters.queryParameters = queryParameters;
+    } else {
+      url = `${apiBaseUrl}/${apiVersion}/stats/${connectionName}/${data}/${spatialDataColumn}`;
+    }
+    const headers = {
+      Authorization: `Bearer ${this.props.accessToken}`,
+      ...this.props.headers
+    };
+    const errorContext = {
+      requestType: "Tile stats",
+      connection: connectionName,
+      type
+    };
+    return requestWithParameters({
+      baseUrl: url,
+      headers,
+      signal,
+      errorContext,
+      parameters
+    }).then(({ extent: { xmin, ymin, xmax, ymax } }) => ({
+      bbox: [xmin, ymin, xmax, ymax]
+    }));
+  }
 };
 
 // src/widget-sources/widget-query-source.ts
@@ -7548,6 +7590,10 @@ var WidgetTilesetSourceImpl = class extends WidgetSource {
       max: aggregationFunctions.max(filteredFeatures, column)
     };
   }
+  /** @experimental */
+  async getExtent() {
+    return Promise.reject(new Error("not implemented"));
+  }
   /****************************************************************************
    * INTERNAL
    */
@@ -7778,6 +7824,12 @@ var WidgetTilesetSource = class extends WidgetSource {
   }) {
     return this._executeWorkerMethod("getRange" /* GET_RANGE */, [options], signal);
   }
+  /** @experimental */
+  async getExtent() {
+    return Promise.resolve({
+      bbox: this.props.spatialDataBounds
+    });
+  }
 };
 
 // src/widget-sources/widget-raster-source.ts
@@ -7894,7 +7946,8 @@ var h3TilesetSource = async function(options) {
         ...options,
         tileFormat: getTileFormat(result),
         spatialDataColumn,
-        spatialDataType: "h3"
+        spatialDataType: "h3",
+        spatialDataBounds: result.bounds
       })
     })
   );
@@ -7915,6 +7968,7 @@ var rasterSource = async function(options) {
         tileFormat: getTileFormat(result),
         spatialDataColumn: "quadbin",
         spatialDataType: "quadbin",
+        spatialDataBounds: result.bounds,
         rasterMetadata: result.raster_metadata
       })
     })
@@ -8014,7 +8068,8 @@ var quadbinTilesetSource = async function(options) {
         ...options,
         tileFormat: getTileFormat(result),
         spatialDataColumn,
-        spatialDataType: "quadbin"
+        spatialDataType: "quadbin",
+        spatialDataBounds: result.bounds
       })
     })
   );
@@ -8115,7 +8170,8 @@ var vectorTilesetSource = async function(options) {
         ...options,
         tileFormat: getTileFormat(result),
         spatialDataColumn,
-        spatialDataType: "geo"
+        spatialDataType: "geo",
+        spatialDataBounds: result.bounds
       })
     })
   );
@@ -8279,6 +8335,250 @@ var basemap_styles_default = {
   DARK_MATTER_NOLABELS: getStyleUrl("dark-matter-nolabels")
 };
 
+// src/fetch-map/vec-expr-evaluator.ts
+import jsep from "jsep";
+function createVecExprEvaluator(expression) {
+  try {
+    const parsed = compile(expression);
+    const evalFun = (context) => evaluate(parsed, context);
+    evalFun.symbols = getSymbols(parsed);
+    return evalFun;
+  } catch {
+    return null;
+  }
+}
+function evaluateVecExpr(expression, context) {
+  try {
+    return createVecExprEvaluator(expression)?.(context);
+  } catch {
+    return null;
+  }
+}
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2[ErrorCode2["InvalidSyntax"] = 0] = "InvalidSyntax";
+  ErrorCode2[ErrorCode2["UnknownIdentifier"] = 1] = "UnknownIdentifier";
+  return ErrorCode2;
+})(ErrorCode || {});
+function validateVecExprSyntax(expression, context) {
+  let parsed;
+  try {
+    parsed = compile(expression);
+  } catch (e) {
+    return {
+      valid: false,
+      errorCode: 0 /* InvalidSyntax */,
+      errorMessage: e && "message" in e ? String(e.message) : String(e)
+    };
+  }
+  return validate(parsed, context);
+}
+function createResultArray(typeTemplate, length2 = typeTemplate.length) {
+  return new Array(length2);
+}
+function isVecLike(a) {
+  return Array.isArray(a) || ArrayBuffer.isView(a);
+}
+var createBinopVec = (scalarBinOp) => (left, right) => {
+  const length2 = Math.min(left.length, right.length);
+  const r = createResultArray(left, length2);
+  for (let i = 0; i < length2; i++) {
+    r[i] = scalarBinOp(left[i], right[i]);
+  }
+  return r;
+};
+var createBinopVecNum = (scalarBinOp) => (left, right) => {
+  const length2 = left.length;
+  const r = createResultArray(left, length2);
+  for (let i = 0; i < length2; i++) {
+    r[i] = scalarBinOp(left[i], right);
+  }
+  return r;
+};
+var createBinopNumVec = (scalarBinOp) => (left, right) => {
+  const length2 = right.length;
+  const r = createResultArray(right, length2);
+  for (let i = 0; i < length2; i++) {
+    r[i] = scalarBinOp(left, right[i]);
+  }
+  return r;
+};
+var createUnopVec = (scalarUnop) => (a) => {
+  const length2 = a.length;
+  const r = createResultArray(a, length2);
+  for (let i = 0; i < length2; i++) {
+    r[i] = scalarUnop(a[i]);
+  }
+  return r;
+};
+function mapDictValues(dict, fun) {
+  return Object.keys(dict).reduce(
+    (acc, key) => {
+      acc[key] = fun(dict[key]);
+      return acc;
+    },
+    {}
+  );
+}
+var binopsNum = {
+  "||": (a, b) => a || b,
+  "&&": (a, b) => a && b,
+  "|": (a, b) => a | b,
+  "^": (a, b) => a ^ b,
+  "&": (a, b) => a & b,
+  "==": (a, b) => Number(a == b),
+  "!=": (a, b) => Number(a != b),
+  "===": (a, b) => Number(a === b),
+  "!==": (a, b) => Number(a !== b),
+  "<": (a, b) => Number(a < b),
+  ">": (a, b) => Number(a > b),
+  "<=": (a, b) => Number(a <= b),
+  ">=": (a, b) => Number(a >= b),
+  "<<": (a, b) => a << b,
+  ">>": (a, b) => a >> b,
+  ">>>": (a, b) => a >>> b,
+  "+": (a, b) => a + b,
+  "-": (a, b) => a - b,
+  "*": (a, b) => a * b,
+  "/": (a, b) => a / b,
+  "%": (a, b) => a % b
+};
+var unopsNum = {
+  "-": (a) => -a,
+  "+": (a) => +a,
+  "~": (a) => ~a,
+  "!": (a) => Number(!a)
+};
+var binopsVector = mapDictValues(binopsNum, createBinopVec);
+var binopsNumVec = mapDictValues(binopsNum, createBinopNumVec);
+var binopsVecNum = mapDictValues(binopsNum, createBinopVecNum);
+var unopsVector = mapDictValues(unopsNum, createUnopVec);
+function getBinop(operator, left, right) {
+  const isLeftVec = isVecLike(left);
+  const isRightVec = isVecLike(right);
+  if (isLeftVec && isRightVec) {
+    return binopsVector[operator];
+  } else if (isLeftVec) {
+    return binopsVecNum[operator];
+  } else if (isRightVec) {
+    return binopsNumVec[operator];
+  } else {
+    return binopsNum[operator];
+  }
+}
+function evaluate(_node, context) {
+  const node = _node;
+  switch (node.type) {
+    case "BinaryExpression": {
+      const left = evaluate(node.left, context);
+      const right = evaluate(node.right, context);
+      const binopFun = getBinop(node.operator, left, right);
+      return binopFun(left, right);
+    }
+    case "ConditionalExpression": {
+      const val = evaluate(node.test, context);
+      if (isVecLike(val)) {
+        const length2 = val.length;
+        const consequentVal = evaluate(node.consequent, context);
+        const alternateVal = evaluate(node.alternate, context);
+        const r = createResultArray(val);
+        for (let i = 0; i < length2; i++) {
+          const entryVal = val[i] ? consequentVal : alternateVal;
+          r[i] = isVecLike(entryVal) ? entryVal[i] ?? NaN : entryVal;
+        }
+        return r;
+      } else {
+        return val ? evaluate(node.consequent, context) : evaluate(node.alternate, context);
+      }
+    }
+    case "Identifier":
+      return context[node.name];
+    case "Literal":
+      return node.value;
+    case "UnaryExpression": {
+      const val = evaluate(node.argument, context);
+      const unopFun = isVecLike(val) ? unopsVector[node.operator] : unopsNum[node.operator];
+      return unopFun(val);
+    }
+    default:
+      return void 0;
+  }
+}
+var validResult = { valid: true };
+function visit(_node, visitor) {
+  const node = _node;
+  visitor(node);
+  switch (node.type) {
+    case "BinaryExpression": {
+      visit(node.left, visitor);
+      visit(node.right, visitor);
+      break;
+    }
+    case "ConditionalExpression": {
+      visit(node.test, visitor);
+      visit(node.consequent, visitor);
+      visit(node.alternate, visitor);
+      break;
+    }
+    case "UnaryExpression": {
+      visit(node.argument, visitor);
+      break;
+    }
+  }
+}
+var supportedExpressionTypes = [
+  "BinaryExpression",
+  "UnaryExpression",
+  "ConditionalExpression",
+  "LogicalExpression",
+  "Identifier",
+  "Literal"
+];
+function validate(_node, context) {
+  const node = _node;
+  const errors = [];
+  visit(node, (node2) => {
+    if (!supportedExpressionTypes.includes(node2.type)) {
+      errors.push({
+        valid: false,
+        errorCode: 0 /* InvalidSyntax */,
+        errorMessage: `Not allowed`
+      });
+      return;
+    }
+    if (node2.type === "Identifier") {
+      if (!Object.prototype.hasOwnProperty.call(context, node2.name)) {
+        return errors.push({
+          valid: false,
+          errorCode: 1 /* UnknownIdentifier */,
+          errorMessage: `"${node2.name}" not found`
+        });
+      }
+    }
+    if (node2.type === "Literal") {
+      if (typeof node2.value !== "number") {
+        return errors.push({
+          valid: false,
+          errorCode: 0 /* InvalidSyntax */,
+          errorMessage: `Only number literals are supported`
+        });
+      }
+    }
+  });
+  return errors.length ? errors[0] : validResult;
+}
+function getSymbols(node) {
+  const symbols = /* @__PURE__ */ new Set();
+  visit(node, (node2) => {
+    if (node2.type === "Identifier") {
+      symbols.add(node2.name);
+    }
+  });
+  return Array.from(symbols);
+}
+function compile(expression) {
+  return jsep(expression);
+}
+
 // node_modules/d3-array/src/ascending.js
 function ascending(a, b) {
   return a == null || b == null ? NaN : a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
@@ -8906,6 +9206,12 @@ var sharedPropMap = {
     wireframe: "wireframe"
   }
 };
+var rasterPropsMap = {
+  isVisible: "visible",
+  visConfig: {
+    opacity: "opacity"
+  }
+};
 var customMarkersPropsMap = {
   color: "getIconColor",
   visConfig: {
@@ -8949,6 +9255,12 @@ function getLayerProps(type, config2, dataset) {
       `Outdated layer type: ${type}. Please open map in CARTO Builder to automatically migrate.`
     );
   }
+  if (type === "raster") {
+    return {
+      propMap: rasterPropsMap,
+      defaultProps: {}
+    };
+  }
   let basePropMap = sharedPropMap;
   if (config2.visConfig?.customMarkers) {
     basePropMap = mergePropMaps(basePropMap, customMarkersPropsMap);
@@ -8969,6 +9281,9 @@ function getLayerProps(type, config2, dataset) {
 }
 function domainFromAttribute(attribute, scaleType, scaleLength) {
   if (scaleType === "ordinal" || scaleType === "point") {
+    if (!attribute.categories) {
+      return [0, 1];
+    }
     return attribute.categories.map((c) => c.category).filter((c) => c !== void 0 && c !== null);
   }
   if (scaleType === "quantile" && attribute.quantiles) {
@@ -9004,7 +9319,7 @@ function calculateDomain(data, name, scaleType, scaleLength) {
   return [0, 1];
 }
 function normalizeAccessor(accessor, data) {
-  if (data.features || data.tilestats) {
+  if (data.features || data.tilestats || data.raster_metadata) {
     return (object, info) => {
       if (object) {
         return accessor(object.properties || object.__source.object.properties);
@@ -9056,7 +9371,6 @@ function getColorAccessor({ name, colorColumn }, scaleType, { aggregation, range
   return { accessor: normalizeAccessor(accessor, data), scale: scale2 };
 }
 function calculateLayerScale(name, scaleType, range, data) {
-  const scale2 = SCALE_FUNCS[scaleType]();
   let domain = [];
   let scaleColor = [];
   if (scaleType !== "identity") {
@@ -9074,9 +9388,13 @@ function calculateLayerScale(name, scaleType, range, data) {
       domain = domain.slice(0, scaleColor.length);
     }
   }
+  return createColorScale(scaleType, domain, scaleColor, UNKNOWN_COLOR);
+}
+function createColorScale(scaleType, domain, range, unknown) {
+  const scale2 = SCALE_FUNCS[scaleType]();
   scale2.domain(domain);
-  scale2.range(scaleColor);
-  scale2.unknown(UNKNOWN_COLOR);
+  scale2.range(range);
+  scale2.unknown(unknown);
   return scale2;
 }
 var FALLBACK_ICON = "data:image/svg+xml;charset=utf-8;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMTAwIDEwMCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4NCiAgPGNpcmNsZSBjeD0iNTAiIGN5PSI1MCIgcj0iNTAiLz4NCjwvc3ZnPg==";
@@ -9191,13 +9509,419 @@ function calculateClusterTextFontSize(radius) {
   return 11;
 }
 
+// src/fetch-map/raster-layer.ts
+var UNKNOWN_COLOR2 = [134, 141, 145];
+var RASTER_COLOR_BANDS = ["red", "green", "blue"];
+function getHasDataPredicate(noData) {
+  if (noData === "nan") {
+    return (v2) => !isNaN(v2);
+  }
+  if (typeof noData === "string") {
+    noData = parseFloat(noData);
+  }
+  if (typeof noData === "number") {
+    return (v2) => v2 !== noData && !isNaN(v2);
+  }
+  return () => true;
+}
+function createRasterColumnLayerDataTransform(transform) {
+  return (data) => {
+    if (!data || !("data" in data) || !data?.data?.cells?.numericProps) {
+      return data;
+    }
+    return transform(data);
+  };
+}
+function createEvaluationContext(numericProps, noData) {
+  const hasData = getHasDataPredicate(noData);
+  const bands = Object.entries(numericProps).map(([bandName, { value }]) => ({
+    bandName,
+    values: value,
+    copied: false
+  }));
+  const length2 = bands[0].values.length;
+  for (let i = 0; i < length2; i++) {
+    let hasSomeData = false;
+    for (let j = 0; j < bands.length; j++) {
+      hasSomeData = hasSomeData || hasData(bands[j].values[i]);
+    }
+    if (!hasSomeData) {
+      for (let j = 0; j < bands.length; j++) {
+        if (!bands[j].copied) {
+          bands[j].copied = true;
+          bands[j].values = Array.from(bands[j].values);
+        }
+        bands[j].values[i] = NaN;
+      }
+    }
+  }
+  const context = bands.reduce(
+    (agg, { bandName, values }) => {
+      agg[bandName] = values;
+      return agg;
+    },
+    {}
+  );
+  return context;
+}
+function createExprDataTransform({
+  colorBand,
+  rasterMetadata,
+  usedSymbols
+}) {
+  if (!colorBand || !colorBand.type || colorBand.type === "none") {
+    return void 0;
+  }
+  const expr = colorBand?.type === "expression" ? colorBand.value : void 0;
+  const vecExprEvaluator = expr ? createVecExprEvaluator(expr) : void 0;
+  const dataTransform = createRasterColumnLayerDataTransform(
+    (dataWrapped) => {
+      const data = dataWrapped.data;
+      if (expr) {
+        const cachedResult = dataWrapped.customExpressionResults?.[expr];
+        if (cachedResult) {
+          return dataWrapped;
+        }
+      }
+      let context = dataWrapped.expressionEvalContext;
+      if (!context) {
+        const usedNumericProps = usedSymbols.reduce(
+          (acc, symbol) => {
+            acc[symbol] = data.cells.numericProps[symbol];
+            return acc;
+          },
+          {}
+        );
+        context = createEvaluationContext(
+          usedNumericProps,
+          rasterMetadata.nodata
+        );
+        dataWrapped = {
+          ...dataWrapped,
+          expressionEvalContext: context
+        };
+      }
+      if (!vecExprEvaluator || !expr) return dataWrapped;
+      const evalResult = vecExprEvaluator(context);
+      return {
+        ...dataWrapped,
+        customExpressionResults: {
+          ...dataWrapped.customExpressionResults,
+          [expr]: evalResult
+        }
+      };
+    }
+  );
+  return dataTransform;
+}
+function combineDataTransforms(dataTransforms) {
+  const actualTransforms = dataTransforms.filter((v2) => v2);
+  if (actualTransforms.length === 0) return void 0;
+  if (actualTransforms.length === 1) return actualTransforms[0];
+  return (data) => actualTransforms.reduce(
+    (aggData, transformFun) => transformFun(aggData),
+    data
+  );
+}
+function createRgbToColorBufferDataTransform({
+  bandDefs,
+  attribute
+}) {
+  return createRasterColumnLayerDataTransform(
+    (dataWrapped) => {
+      const length2 = dataWrapped.length;
+      const getBandBufferOrValue = (colorBand) => {
+        if (colorBand?.type === "expression") {
+          return dataWrapped.customExpressionResults?.[colorBand.value];
+        }
+        if (colorBand?.type === "band") {
+          return dataWrapped.expressionEvalContext?.[colorBand.value];
+        }
+        return 0;
+      };
+      const red = getBandBufferOrValue(bandDefs.red);
+      const green = getBandBufferOrValue(bandDefs.green);
+      const blue = getBandBufferOrValue(bandDefs.blue);
+      const colorBuffer = new Uint8Array(length2 * 4);
+      for (let inputIndex = 0, outputIndex = 0; inputIndex < length2; inputIndex++, outputIndex += 4) {
+        const redRaw = typeof red === "number" ? red : red ? red[inputIndex] : NaN;
+        const greenRaw = typeof green === "number" ? green : green ? green[inputIndex] : NaN;
+        const blueRaw = typeof blue === "number" ? blue : blue ? blue[inputIndex] : NaN;
+        if (isNaN(redRaw) && isNaN(greenRaw) && isNaN(blueRaw)) {
+          bufferSetRgba(colorBuffer, outputIndex, 0, 0, 0, 0);
+        } else {
+          bufferSetRgba(
+            colorBuffer,
+            outputIndex,
+            redRaw,
+            greenRaw,
+            blueRaw,
+            255
+          );
+        }
+      }
+      dataWrapped.customExpressionResults = void 0;
+      dataWrapped.expressionEvalContext = void 0;
+      return {
+        ...dataWrapped,
+        attributes: {
+          [attribute]: colorBuffer
+        }
+      };
+    }
+  );
+}
+function getUsedSymbols(colorBands) {
+  return Array.from(
+    colorBands.reduce((symbols, band) => {
+      if (band.type === "expression") {
+        const expressionSymbols = createVecExprEvaluator(band.value)?.symbols || [];
+        expressionSymbols.forEach((symbol) => symbols.add(symbol));
+      }
+      if (band.type === "band") {
+        symbols.add(band.value);
+      }
+      return symbols;
+    }, /* @__PURE__ */ new Set())
+  );
+}
+function getRasterTileLayerStylePropsRgb({
+  layerConfig,
+  rasterMetadata,
+  visualChannels
+}) {
+  const { visConfig } = layerConfig;
+  const { colorBands } = visConfig;
+  const bandDefs = {
+    red: colorBands?.find((band) => band.band === "red"),
+    green: colorBands?.find((band) => band.band === "green"),
+    blue: colorBands?.find((band) => band.band === "blue")
+  };
+  const rgbToInstanceFillColorsDataTransform = createRgbToColorBufferDataTransform({
+    bandDefs,
+    attribute: "instanceFillColors"
+  });
+  const usedSymbols = colorBands ? getUsedSymbols(colorBands) : [];
+  const bandTransforms = RASTER_COLOR_BANDS.map(
+    (band) => createExprDataTransform({
+      colorBand: bandDefs[band],
+      rasterMetadata,
+      usedSymbols
+    })
+  );
+  const combinedDataTransform = combineDataTransforms([
+    ...bandTransforms,
+    rgbToInstanceFillColorsDataTransform
+  ]);
+  return {
+    dataTransform: combinedDataTransform,
+    updateTriggers: getRasterTileLayerUpdateTriggers({
+      layerConfig,
+      visualChannels
+    })
+  };
+}
+function createBandColorScaleDataTransform({
+  bandName,
+  scaleFun,
+  nodata,
+  attribute
+}) {
+  const hasData = getHasDataPredicate(nodata);
+  return createRasterColumnLayerDataTransform(
+    (dataWrapped) => {
+      const length2 = dataWrapped.length;
+      const bandBuffer = dataWrapped.data.cells.numericProps[bandName].value;
+      const colorBuffer = new Uint8Array(length2 * 4);
+      for (let i = 0; i < length2; i++) {
+        const rawValue = bandBuffer[i];
+        if (!hasData(rawValue)) {
+          bufferSetRgba(colorBuffer, i * 4, 0, 0, 0, 0);
+        } else {
+          const colorRgb = scaleFun(rawValue);
+          bufferSetRgba(
+            colorBuffer,
+            i * 4,
+            colorRgb[0],
+            colorRgb[1],
+            colorRgb[2],
+            255
+          );
+        }
+      }
+      return {
+        ...dataWrapped,
+        attributes: {
+          [attribute]: colorBuffer
+        }
+      };
+    }
+  );
+}
+function domainFromRasterMetadataBand(band, scaleType, colorRange) {
+  if (scaleType === "ordinal") {
+    return colorRange.colorMap?.map(([value]) => value) || [];
+  }
+  if (scaleType === "custom") {
+    if (colorRange.uiCustomScaleType === "logarithmic") {
+      if (colorRange.colorMap) {
+        return colorRange.colorMap?.map(([value]) => value) || [];
+      }
+      return [band.stats.min, band.stats.max];
+    } else {
+      return colorRange.colorMap?.map(([value]) => value) || [];
+    }
+  }
+  const scaleLength = colorRange.colors.length;
+  if (scaleType === "quantile") {
+    const quantiles = band.stats.quantiles?.[scaleLength];
+    if (!quantiles) {
+      return [0, 1];
+    }
+    return [band.stats.min, ...quantiles, band.stats.max];
+  }
+  return [band.stats.min, band.stats.max];
+}
+function getRasterTileLayerStylePropsScaledBand({
+  layerConfig,
+  rasterMetadata,
+  visualChannels
+}) {
+  const { visConfig } = layerConfig;
+  const { colorField } = visualChannels;
+  const { rasterStyleType } = visConfig;
+  const colorRange = rasterStyleType === "ColorRange" ? visConfig.colorRange : visConfig.uniqueValuesColorRange;
+  const scaleType = rasterStyleType === "ColorRange" ? visualChannels.colorScale : "ordinal";
+  const bandInfo = rasterMetadata.bands.find(
+    (band) => band.name === colorField?.name
+  );
+  if (!colorField?.name || !scaleType || !colorRange || !bandInfo) {
+    return {};
+  }
+  const domain = domainFromRasterMetadataBand(bandInfo, scaleType, colorRange);
+  const scaleFun = createColorScale(
+    scaleType,
+    domain,
+    colorRange.colors.map(hexToRGB),
+    UNKNOWN_COLOR2
+  );
+  const bandColorScaleDataTransform = createBandColorScaleDataTransform({
+    bandName: bandInfo.name,
+    scaleFun,
+    nodata: bandInfo?.nodata ?? rasterMetadata.nodata,
+    attribute: "instanceFillColors"
+  });
+  return {
+    dataTransform: bandColorScaleDataTransform,
+    updateTriggers: getRasterTileLayerUpdateTriggers({
+      layerConfig,
+      visualChannels
+    })
+  };
+}
+function getRasterTileLayerStyleProps({
+  layerConfig,
+  visualChannels,
+  rasterMetadata
+}) {
+  const { visConfig } = layerConfig;
+  const { rasterStyleType } = visConfig;
+  if (rasterStyleType === "Rgb") {
+    return getRasterTileLayerStylePropsRgb({
+      layerConfig,
+      rasterMetadata,
+      visualChannels
+    });
+  } else {
+    return getRasterTileLayerStylePropsScaledBand({
+      layerConfig,
+      rasterMetadata,
+      visualChannels
+    });
+  }
+}
+function getRasterTileLayerUpdateTriggers({
+  layerConfig,
+  visualChannels
+}) {
+  const { visConfig } = layerConfig;
+  const { rasterStyleType } = visConfig;
+  const getFillColorUpdateTriggers = {
+    rasterStyleType
+  };
+  if (rasterStyleType === "ColorRange") {
+    getFillColorUpdateTriggers.colorRange = visConfig.colorRange?.colors;
+    getFillColorUpdateTriggers.colorMap = visConfig.colorRange?.colorMap;
+    getFillColorUpdateTriggers.colorScale = visualChannels.colorScale;
+    getFillColorUpdateTriggers.colorFieldId = visualChannels.colorField?.name;
+  } else if (rasterStyleType === "UniqueValues") {
+    getFillColorUpdateTriggers.colorMap = visConfig.uniqueValuesColorRange?.colorMap;
+    getFillColorUpdateTriggers.colorFieldId = visualChannels.colorField?.name;
+  } else if (rasterStyleType === "Rgb") {
+    getFillColorUpdateTriggers.colorBands = visConfig.colorBands;
+  }
+  return {
+    getFillColor: getFillColorUpdateTriggers
+  };
+}
+function bufferSetRgba(target, index, r, g, b, a) {
+  target[index + 0] = r;
+  target[index + 1] = g;
+  target[index + 2] = b;
+  target[index + 3] = a;
+}
+function hexToRGB(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);
+  return [r, g, b];
+}
+
 // src/fetch-map/parse-map.ts
+function getLayerDescriptor({
+  mapConfig,
+  layer,
+  dataset
+}) {
+  const { filters, visState } = mapConfig;
+  const { layerBlending, interactionConfig } = visState;
+  const { id, type, config: config2, visualChannels } = layer;
+  const { data, id: datasetId } = dataset;
+  const { propMap, defaultProps: defaultProps2 } = getLayerProps(type, config2, dataset);
+  const styleProps = createStyleProps(config2, propMap);
+  const { channelProps, scales } = createChannelProps(
+    id,
+    type,
+    config2,
+    visualChannels,
+    data,
+    dataset
+  );
+  const layerDescriptor = {
+    type,
+    filters: isEmptyObject(filters) || isRemoteCalculationSupported(dataset) ? void 0 : filters[datasetId],
+    props: {
+      id,
+      data,
+      ...defaultProps2,
+      ...createInteractionProps(interactionConfig),
+      ...styleProps,
+      ...channelProps,
+      ...createParametersProp(layerBlending, styleProps.parameters || {}),
+      // Must come after style
+      ...createLoadOptions(data.accessToken)
+    },
+    scales
+  };
+  return layerDescriptor;
+}
 function parseMap(json) {
   const { keplerMapConfig, datasets, token } = json;
   assert2(keplerMapConfig.version === "v1", "Only support Kepler v1");
-  const config2 = keplerMapConfig.config;
-  const { filters, mapState, mapStyle, popupSettings, legendSettings } = config2;
-  const { layers, layerBlending, interactionConfig } = config2.visState;
+  const mapConfig = keplerMapConfig.config;
+  const { mapState, mapStyle, popupSettings, legendSettings, visState } = mapConfig;
+  const { layers } = visState;
+  const layersReverse = [...layers].reverse();
   return {
     id: json.id,
     title: json.title,
@@ -9210,45 +9934,19 @@ function parseMap(json) {
     popupSettings,
     legendSettings,
     token,
-    layers: layers.reverse().map(({ id, type, config: config3, visualChannels }) => {
+    layers: layersReverse.map((layer) => {
       try {
-        const { dataId } = config3;
+        const { dataId } = layer.config;
         const dataset = datasets.find(
           (d) => d.id === dataId
         );
         assert2(dataset, `No dataset matching dataId: ${dataId}`);
-        const { data } = dataset;
-        assert2(data, `No data loaded for dataId: ${dataId}`);
-        const { propMap, defaultProps: defaultProps2 } = getLayerProps(type, config3, dataset);
-        const styleProps = createStyleProps(config3, propMap);
-        const { channelProps, scales } = createChannelProps(
-          id,
-          type,
-          config3,
-          visualChannels,
-          data,
+        const layerDescriptor = getLayerDescriptor({
+          mapConfig,
+          layer,
           dataset
-        );
-        const layer = {
-          type,
-          filters: isEmptyObject(filters) || isRemoteCalculationSupported(dataset) ? void 0 : filters[dataId],
-          props: {
-            id,
-            data,
-            ...defaultProps2,
-            ...createInteractionProps(interactionConfig),
-            ...styleProps,
-            ...channelProps,
-            ...createParametersProp(
-              layerBlending,
-              styleProps.parameters || {}
-            ),
-            // Must come after style
-            ...createLoadOptions(token)
-          },
-          scales
-        };
-        return layer;
+        });
+        return layerDescriptor;
       } catch (e) {
         console.error(e.message);
         return void 0;
@@ -9329,9 +10027,41 @@ function createChannelProps(id, layerType, config2, visualChannels, data, datase
     strokeColorScale,
     weightField
   } = visualChannels;
+  if (layerType === "raster") {
+    const rasterStyleType = config2.visConfig.rasterStyleType;
+    if (rasterStyleType === "Rgb") {
+      return {
+        channelProps: getRasterTileLayerStylePropsRgb({
+          layerConfig: config2,
+          rasterMetadata: data.raster_metadata,
+          visualChannels
+        }),
+        scales: {}
+      };
+    } else {
+      return {
+        channelProps: getRasterTileLayerStylePropsScaledBand({
+          layerConfig: config2,
+          visualChannels,
+          rasterMetadata: data.raster_metadata
+        }),
+        scales: {
+          ...colorField && {
+            fillColor: {
+              field: colorField,
+              type: "ordinal",
+              domain: [],
+              range: []
+            }
+          }
+        }
+      };
+    }
+  }
   const { heightField, heightScale } = visualChannels;
   const { textLabel, visConfig } = config2;
   const result = {};
+  const updateTriggers = {};
   const scales = {};
   if (colorField) {
     const { colorAggregation: aggregation, colorRange: range } = visConfig;
@@ -9343,7 +10073,7 @@ function createChannelProps(id, layerType, config2, visualChannels, data, datase
       data
     );
     result.getFillColor = accessor;
-    scales.fillColor = {
+    scales.fillColor = updateTriggers.getFillColor = {
       field: colorField,
       type: colorScale,
       ...domainAndRangeFromScale(scale2)
@@ -9362,6 +10092,7 @@ function createChannelProps(id, layerType, config2, visualChannels, data, datase
     result.getWeight = (d) => {
       return d.properties[aggregationExpAlias];
     };
+    updateTriggers.getWeight = aggregationExpAlias;
     result.getPointRadius = (d, info) => {
       return calculateClusterRadius(
         d.properties,
@@ -9370,11 +10101,16 @@ function createChannelProps(id, layerType, config2, visualChannels, data, datase
         aggregationExpAlias
       );
     };
+    updateTriggers.getPointRadius = {
+      aggregationExpAlias,
+      radiusRange: visConfig.radiusRange
+    };
     result.textCharacterSet = "auto";
     result.textFontFamily = "Inter, sans";
     result.textFontSettings = { sdf: true };
     result.textFontWeight = 600;
     result.getText = (d) => TEXT_NUMBER_FORMATTER.format(d.properties[aggregationExpAlias]);
+    updateTriggers.getText = aggregationExpAlias;
     result.getTextColor = config2.textLabel[TEXT_LABEL_INDEX].color;
     result.textOutlineColor = [
       ...config2.textLabel[TEXT_LABEL_INDEX].outlineColor,
@@ -9391,6 +10127,10 @@ function createChannelProps(id, layerType, config2, visualChannels, data, datase
       );
       return calculateClusterTextFontSize(radius);
     };
+    updateTriggers.getTextSize = {
+      aggregationExpAlias,
+      radiusRange: visConfig.radiusRange
+    };
   }
   if (radiusField) {
     const { accessor, scale: scale2 } = getSizeAccessor(
@@ -9401,7 +10141,7 @@ function createChannelProps(id, layerType, config2, visualChannels, data, datase
       data
     );
     result.getPointRadius = accessor;
-    scales.pointRadius = {
+    scales.pointRadius = updateTriggers.getPointRadius = {
       field: radiusField,
       type: radiusScale || "identity",
       ...domainAndRangeFromScale(scale2)
@@ -9418,7 +10158,7 @@ function createChannelProps(id, layerType, config2, visualChannels, data, datase
       data
     );
     result.getLineColor = accessor;
-    scales.lineColor = {
+    scales.lineColor = updateTriggers.getLineColor = {
       field: strokeColorField,
       type: strokeColorScale,
       ...domainAndRangeFromScale(scale2)
@@ -9433,7 +10173,7 @@ function createChannelProps(id, layerType, config2, visualChannels, data, datase
       data
     );
     result.getElevation = accessor;
-    scales.elevation = {
+    scales.elevation = updateTriggers.getElevation = {
       field: heightField,
       type: heightScale || "identity",
       ...domainAndRangeFromScale(scale2)
@@ -9448,7 +10188,7 @@ function createChannelProps(id, layerType, config2, visualChannels, data, datase
       data
     );
     result.getWeight = accessor;
-    scales.weight = {
+    scales.weight = updateTriggers.getWeight = {
       field: weightField,
       type: "identity",
       ...domainAndRangeFromScale(scale2)
@@ -9469,6 +10209,12 @@ function createChannelProps(id, layerType, config2, visualChannels, data, datase
       { fallbackUrl: customMarkersUrl, maxIconSize, useMaskedIcons },
       data
     );
+    updateTriggers.getIcon = {
+      customMarkersUrl,
+      customMarkersRange,
+      maxIconSize,
+      useMaskedIcons
+    };
     result._subLayerProps = {
       "points-icon": {
         loadOptions: {
@@ -9485,9 +10231,11 @@ function createChannelProps(id, layerType, config2, visualChannels, data, datase
     };
     if (getFillColor && useMaskedIcons) {
       result.getIconColor = getFillColor;
+      updateTriggers.getIconColor = updateTriggers.getFillColor;
     }
     if (getPointRadius) {
       result.getIconSize = getPointRadius;
+      updateTriggers.getIconSize = updateTriggers.getPointRadius;
     }
     if (visualChannels.rotationField) {
       const { accessor } = getSizeAccessor(
@@ -9498,6 +10246,7 @@ function createChannelProps(id, layerType, config2, visualChannels, data, datase
         data
       );
       result.getIconAngle = negateAccessor(accessor);
+      updateTriggers.getIconAngle = updateTriggers.getRotationField;
     }
   } else if (layerType === "tileset") {
     result.pointType = "circle";
@@ -9542,7 +10291,13 @@ function createChannelProps(id, layerType, config2, visualChannels, data, datase
       }
     };
   }
-  return { channelProps: result, scales };
+  return {
+    channelProps: {
+      ...result,
+      updateTriggers
+    },
+    scales
+  };
 }
 function createLoadOptions(accessToken) {
   return {
@@ -10189,9 +10944,14 @@ export {
   WidgetSource,
   WidgetTableSource,
   WidgetTilesetSource,
+  ErrorCode as _ErrorCode,
   _buildFeatureFilter,
+  createVecExprEvaluator as _createVecExprEvaluator,
   domainFromValues as _domainFromValues,
+  evaluateVecExpr as _evaluateVecExpr,
   _getHexagonResolution,
+  getRasterTileLayerStyleProps as _getRasterTileLayerStyleProps,
+  validateVecExprSyntax as _validateVecExprSyntax,
   addFilter,
   aggregate,
   aggregationFunctions,
@@ -10204,9 +10964,11 @@ export {
   buildStatsUrl,
   calculateClusterRadius,
   calculateClusterTextFontSize,
+  calculateLayerScale,
   clearDefaultRequestCache,
   clearFilters,
   configureSource,
+  createColorScale,
   createPolygonSpatialFilter,
   createViewportSpatialFilter,
   fetchBasemapProps,
@@ -10221,6 +10983,7 @@ export {
   getDefaultAggregationExpColumnAliasForLayerType,
   getFilter,
   getIconUrlAccessor,
+  getLayerDescriptor,
   getLayerProps,
   getMaxMarkerSize,
   getSizeAccessor,