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

package/build/api-client.js

@@ -8335,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;
@@ -8962,6 +9206,12 @@ var sharedPropMap = {
     wireframe: "wireframe"
   }
 };
+var rasterPropsMap = {
+  isVisible: "visible",
+  visConfig: {
+    opacity: "opacity"
+  }
+};
 var customMarkersPropsMap = {
   color: "getIconColor",
   visConfig: {
@@ -9005,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);
@@ -9025,16 +9281,19 @@ 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) {
-    return attribute.quantiles.global ? attribute.quantiles.global[scaleLength] : attribute.quantiles[scaleLength];
+    return "global" in attribute.quantiles ? attribute.quantiles.global[scaleLength] : attribute.quantiles[scaleLength];
   }
   let { min: min2 } = attribute;
   if (scaleType === "log" && min2 === 0) {
     min2 = 1e-5;
   }
-  return [min2, attribute.max];
+  return [min2 ?? 0, attribute.max ?? 1];
 }
 function domainFromValues(values, scaleType) {
   if (scaleType === "ordinal" || scaleType === "point") {
@@ -9055,12 +9314,14 @@ function calculateDomain(data, name, scaleType, scaleLength) {
   if (data.tilestats) {
     const { attributes } = data.tilestats.layers[0];
     const attribute = attributes.find((a) => a.attribute === name);
-    return domainFromAttribute(attribute, scaleType, scaleLength);
+    if (attribute) {
+      return domainFromAttribute(attribute, 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);
@@ -9112,7 +9373,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") {
@@ -9130,9 +9390,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==";
@@ -9247,13 +9511,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,
@@ -9266,45 +9936,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;
@@ -9383,11 +10027,52 @@ function createChannelProps(id, layerType, config2, visualChannels, data, datase
     radiusScale,
     strokeColorField,
     strokeColorScale,
+    sizeField: strokeWidthField,
+    sizeScale: strokeWidthScale,
     weightField
   } = visualChannels;
+  if (layerType === "raster") {
+    const rasterMetadata = data.raster_metadata;
+    if (!rasterMetadata) {
+      return {
+        channelProps: {},
+        scales: {}
+      };
+    }
+    const rasterStyleType = config2.visConfig.rasterStyleType;
+    if (rasterStyleType === "Rgb") {
+      return {
+        channelProps: getRasterTileLayerStylePropsRgb({
+          layerConfig: config2,
+          rasterMetadata,
+          visualChannels
+        }),
+        scales: {}
+      };
+    } else {
+      return {
+        channelProps: getRasterTileLayerStylePropsScaledBand({
+          layerConfig: config2,
+          visualChannels,
+          rasterMetadata
+        }),
+        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;
@@ -9399,7 +10084,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)
@@ -9418,6 +10103,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,
@@ -9426,11 +10112,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,
@@ -9447,6 +10138,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(
@@ -9457,7 +10152,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)
@@ -9474,12 +10169,27 @@ function createChannelProps(id, layerType, config2, visualChannels, data, datase
       data
     );
     result.getLineColor = accessor;
-    scales.lineColor = {
+    scales.lineColor = updateTriggers.getLineColor = {
       field: strokeColorField,
       type: strokeColorScale,
       ...domainAndRangeFromScale(scale2)
     };
   }
+  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)
+    };
+  }
   if (heightField && visConfig.enable3d) {
     const { accessor, scale: scale2 } = getSizeAccessor(
       heightField,
@@ -9489,7 +10199,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)
@@ -9504,7 +10214,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)
@@ -9525,6 +10235,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: {
@@ -9541,9 +10257,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(
@@ -9554,6 +10272,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";
@@ -9598,7 +10317,13 @@ function createChannelProps(id, layerType, config2, visualChannels, data, datase
       }
     };
   }
-  return { channelProps: result, scales };
+  return {
+    channelProps: {
+      ...result,
+      updateTriggers
+    },
+    scales
+  };
 }
 function createLoadOptions(accessToken) {
   return {
@@ -10245,9 +10970,15 @@ export {
   WidgetSource,
   WidgetTableSource,
   WidgetTilesetSource,
+  ErrorCode as _ErrorCode,
+  applyLayerGroupFilters as _applyLayerGroupFilters,
   _buildFeatureFilter,
+  createVecExprEvaluator as _createVecExprEvaluator,
   domainFromValues as _domainFromValues,
+  evaluateVecExpr as _evaluateVecExpr,
   _getHexagonResolution,
+  getRasterTileLayerStyleProps as _getRasterTileLayerStyleProps,
+  validateVecExprSyntax as _validateVecExprSyntax,
   addFilter,
   aggregate,
   aggregationFunctions,
@@ -10260,9 +10991,11 @@ export {
   buildStatsUrl,
   calculateClusterRadius,
   calculateClusterTextFontSize,
+  calculateLayerScale,
   clearDefaultRequestCache,
   clearFilters,
   configureSource,
+  createColorScale,
   createPolygonSpatialFilter,
   createViewportSpatialFilter,
   fetchBasemapProps,
@@ -10277,6 +11010,7 @@ export {
   getDefaultAggregationExpColumnAliasForLayerType,
   getFilter,
   getIconUrlAccessor,
+  getLayerDescriptor,
   getLayerProps,
   getMaxMarkerSize,
   getSizeAccessor,