@carto/api-client 0.5.16 → 0.5.18-alpha.colormapfix-1

package/build/api-client.cjs

@@ -125,9 +125,16 @@ __export(src_exports, {
   WidgetSource: () => WidgetSource,
   WidgetTableSource: () => WidgetTableSource,
   WidgetTilesetSource: () => WidgetTilesetSource,
+  _ErrorCode: () => ErrorCode,
+  _applyLayerGroupFilters: () => applyLayerGroupFilters,
   _buildFeatureFilter: () => _buildFeatureFilter,
+  _createVecExprEvaluator: () => createVecExprEvaluator,
   _domainFromValues: () => domainFromValues,
+  _evaluateVecExpr: () => evaluateVecExpr,
   _getHexagonResolution: () => _getHexagonResolution,
+  _getLog10ScaleSteps: () => getLog10ScaleSteps,
+  _getRasterTileLayerStyleProps: () => getRasterTileLayerStyleProps,
+  _validateVecExprSyntax: () => validateVecExprSyntax,
   addFilter: () => addFilter,
   aggregate: () => aggregate,
   aggregationFunctions: () => aggregationFunctions,
@@ -140,9 +147,11 @@ __export(src_exports, {
   buildStatsUrl: () => buildStatsUrl,
   calculateClusterRadius: () => calculateClusterRadius,
   calculateClusterTextFontSize: () => calculateClusterTextFontSize,
+  calculateLayerScale: () => calculateLayerScale,
   clearDefaultRequestCache: () => clearDefaultRequestCache,
   clearFilters: () => clearFilters,
   configureSource: () => configureSource,
+  createColorScale: () => createColorScale,
   createPolygonSpatialFilter: () => createPolygonSpatialFilter,
   createViewportSpatialFilter: () => createViewportSpatialFilter,
   fetchBasemapProps: () => fetchBasemapProps,
@@ -157,6 +166,7 @@ __export(src_exports, {
   getDefaultAggregationExpColumnAliasForLayerType: () => getDefaultAggregationExpColumnAliasForLayerType,
   getFilter: () => getFilter,
   getIconUrlAccessor: () => getIconUrlAccessor,
+  getLayerDescriptor: () => getLayerDescriptor,
   getLayerProps: () => getLayerProps,
   getMaxMarkerSize: () => getMaxMarkerSize,
   getSizeAccessor: () => getSizeAccessor,
@@ -8808,11 +8818,253 @@ var basemap_styles_default = {
   DARK_MATTER_NOLABELS: getStyleUrl("dark-matter-nolabels")
 };
 
-// src/fetch-map/fetch-map.ts
+// src/fetch-map/raster-layer.ts
 init_cjs_shims();
 
-// src/fetch-map/parse-map.ts
+// src/fetch-map/vec-expr-evaluator.ts
 init_cjs_shims();
+var import_jsep = __toESM(require("jsep"), 1);
+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 (0, import_jsep.default)(expression);
+}
 
 // src/fetch-map/layer-map.ts
 init_cjs_shims();
@@ -9411,6 +9663,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 = {
@@ -9427,7 +9710,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",
@@ -9460,6 +9755,12 @@ var sharedPropMap = {
     wireframe: "wireframe"
   }
 };
+var rasterPropsMap = {
+  isVisible: "visible",
+  visConfig: {
+    opacity: "opacity"
+  }
+};
 var customMarkersPropsMap = {
   color: "getIconColor",
   visConfig: {
@@ -9503,6 +9804,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);
@@ -9523,16 +9830,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") {
@@ -9553,12 +9863,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);
@@ -9591,46 +9903,78 @@ 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,
+    colorColumn ? "identity" : scaleType,
     range,
     data
   );
   const alpha = opacityToAlpha(opacity);
-  let accessorKeys = getAccessorKeys(name, aggregation);
+  let accessorKeys = getAccessorKeys(colorColumn || name, aggregation);
   const accessor = (properties) => {
     if (!(accessorKeys[0] in properties)) {
       accessorKeys = findAccessorKey(accessorKeys, properties);
     }
     const propertyValue = properties[accessorKeys[0]];
-    const { r, g, b } = rgb(scale2(propertyValue));
-    return [r, g, b, propertyValue === null ? 0 : alpha];
+    const scaled = scale2(propertyValue);
+    const rgb2 = typeof scaled === "string" ? hexToRGB(scaled) : scaled;
+    return [...rgb2, propertyValue === null ? 0 : alpha];
+  };
+  return {
+    accessor: normalizeAccessor(accessor, data),
+    scaleDomain: scale2.domain(),
+    domain,
+    range: (scale2.range() || []).map(rgbToHex)
   };
-  return { accessor: normalizeAccessor(accessor, data), scale: scale2 };
 }
 function calculateLayerScale(name, scaleType, range, data) {
-  const scale2 = SCALE_FUNCS[scaleType]();
   let domain = [];
+  let scaleDomain;
   let scaleColor = [];
+  const { colors } = range;
   if (scaleType !== "identity") {
-    const { colorMap, colors } = range;
-    if (Array.isArray(colorMap)) {
+    if (range.colorMap) {
+      const { colorMap } = range;
+      scaleDomain = [];
       colorMap.forEach(([value, color2]) => {
-        domain.push(value);
+        scaleDomain.push(value);
         scaleColor.push(color2);
       });
+      domain = scaleDomain;
     } else {
-      domain = calculateDomain(data, name, scaleType, colors.length);
-      scaleColor = colors;
+      if (scaleType === "custom" && 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 {
+        domain = calculateDomain(data, name, scaleType, colors.length);
+        scaleColor = colors;
+      }
     }
     if (scaleType === "ordinal") {
       domain = domain.slice(0, scaleColor.length);
     }
   }
+  return {
+    scale: createColorScale(
+      scaleType,
+      scaleDomain || domain,
+      scaleColor.map(hexToRGB),
+      UNKNOWN_COLOR_RGB
+    ),
+    domain
+  };
+}
+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==";
@@ -9680,9 +10024,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);
   }
@@ -9694,7 +10042,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,
@@ -9745,13 +10098,424 @@ 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") {
+      return getLog10ScaleSteps({
+        min: band.stats.min,
+        max: band.stats.max,
+        steps: colorRange.colors.length
+      });
+    } 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(hexToRGB2),
+    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 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);
+  return [r, g, b];
+}
+
+// src/fetch-map/fetch-map.ts
+init_cjs_shims();
+
 // src/fetch-map/parse-map.ts
+init_cjs_shims();
+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,
@@ -9764,45 +10528,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;
@@ -9867,43 +10605,63 @@ 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,
-    weightField
-  } = visualChannels;
-  const { heightField, heightScale } = 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: {}
+        // TODO
+      };
+    } else {
+      return {
+        channelProps: getRasterTileLayerStylePropsScaledBand({
+          layerConfig: config2,
+          visualChannels,
+          rasterMetadata
+        }),
+        scales: {
+          // TODO
+        }
+      };
+    }
+  }
   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 = {
-      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(
@@ -9916,6 +10674,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,
@@ -9924,11 +10683,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,
@@ -9945,68 +10709,107 @@ function createChannelProps(id, layerType, config2, visualChannels, data, datase
       );
       return calculateClusterTextFontSize(radius);
     };
-  }
-  if (radiusField) {
-    const { accessor, scale: scale2 } = getSizeAccessor(
-      radiusField,
-      radiusScale,
-      visConfig.sizeAggregation,
-      visConfig.radiusRange || visConfig.sizeRange,
-      data
-    );
-    result.getPointRadius = accessor;
-    scales.pointRadius = {
-      field: radiusField,
-      type: radiusScale || "identity",
-      ...domainAndRangeFromScale(scale2)
+    updateTriggers.getTextSize = {
+      aggregationExpAlias,
+      radiusRange: visConfig.radiusRange
     };
   }
-  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 = {
-      field: strokeColorField,
-      type: strokeColorScale,
-      ...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 (heightField && visConfig.enable3d) {
-    const { accessor, scale: scale2 } = getSizeAccessor(
-      heightField,
-      heightScale,
-      visConfig.heightAggregation,
-      visConfig.heightRange || visConfig.sizeRange,
-      data
-    );
-    result.getElevation = accessor;
-    scales.elevation = {
-      field: heightField,
-      type: heightScale || "identity",
-      ...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 (weightField) {
-    const { accessor, scale: scale2 } = getSizeAccessor(
-      weightField,
-      void 0,
-      visConfig.weightAggregation,
-      void 0,
-      data
-    );
-    result.getWeight = accessor;
-    scales.weight = {
-      field: weightField,
-      type: "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
+      };
+    }
+  }
+  {
+    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
+      };
+    }
+  }
+  {
+    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);
@@ -10023,6 +10826,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: {
@@ -10039,9 +10848,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(
@@ -10052,6 +10863,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";
@@ -10096,7 +10908,13 @@ function createChannelProps(id, layerType, config2, visualChannels, data, datase
       }
     };
   }
-  return { channelProps: result, scales };
+  return {
+    channelProps: {
+      ...result,
+      updateTriggers
+    },
+    scales
+  };
 }
 function createLoadOptions(accessToken) {
   return {
@@ -10752,9 +11570,16 @@ function hashBuckets(initialCount) {
   WidgetSource,
   WidgetTableSource,
   WidgetTilesetSource,
+  _ErrorCode,
+  _applyLayerGroupFilters,
   _buildFeatureFilter,
+  _createVecExprEvaluator,
   _domainFromValues,
+  _evaluateVecExpr,
   _getHexagonResolution,
+  _getLog10ScaleSteps,
+  _getRasterTileLayerStyleProps,
+  _validateVecExprSyntax,
   addFilter,
   aggregate,
   aggregationFunctions,
@@ -10767,9 +11592,11 @@ function hashBuckets(initialCount) {
   buildStatsUrl,
   calculateClusterRadius,
   calculateClusterTextFontSize,
+  calculateLayerScale,
   clearDefaultRequestCache,
   clearFilters,
   configureSource,
+  createColorScale,
   createPolygonSpatialFilter,
   createViewportSpatialFilter,
   fetchBasemapProps,
@@ -10784,6 +11611,7 @@ function hashBuckets(initialCount) {
   getDefaultAggregationExpColumnAliasForLayerType,
   getFilter,
   getIconUrlAccessor,
+  getLayerDescriptor,
   getLayerProps,
   getMaxMarkerSize,
   getSizeAccessor,