@carto/api-client 0.5.15-alpha.raster-5 → 0.5.16

package/build/api-client.js

@@ -6152,7 +6152,8 @@ var AVAILABLE_MODELS = [
   "timeseries",
   "range",
   "scatterplot",
-  "table"
+  "table",
+  "aggregations"
 ];
 var { V3 } = ApiVersion;
 var REQUEST_GET_MAX_URL_LENGTH = 2048;
@@ -6593,6 +6594,30 @@ var WidgetRemoteSource = class extends WidgetSource {
       categories: res.metadata?.categories
     }));
   }
+  async getAggregations(options) {
+    const {
+      signal,
+      filters = this.props.filters,
+      filterOwner,
+      spatialFilter,
+      spatialFiltersMode,
+      aggregations
+    } = options;
+    return executeModel({
+      model: "aggregations",
+      source: {
+        ...this.getModelSource(filters, filterOwner),
+        spatialFiltersMode,
+        spatialFilter
+      },
+      params: {
+        aggregations
+      },
+      opts: { signal, headers: this.props.headers }
+    }).then((res) => ({
+      rows: res.rows.map((row) => normalizeObjectKeys(row))
+    }));
+  }
   /** @experimental */
   async getExtent(options = {}) {
     const { signal, filters = this.props.filters, filterOwner } = options;
@@ -7392,6 +7417,7 @@ var WidgetTilesetSourceImpl = class extends WidgetSource {
       assertColumn(this._features, column);
     }
     const targetOperation = aggregationFunctions[operation2];
+    assert2(targetOperation, `Unsupported aggregation operation: ${operation2}`);
     return {
       value: targetOperation(filteredFeatures, column, joinOperation)
     };
@@ -7590,6 +7616,39 @@ var WidgetTilesetSourceImpl = class extends WidgetSource {
       max: aggregationFunctions.max(filteredFeatures, column)
     };
   }
+  async getAggregations({
+    aggregations,
+    filters,
+    filterOwner,
+    spatialFilter
+  }) {
+    const filteredFeatures = this._getFilteredFeatures(
+      spatialFilter,
+      filters,
+      filterOwner
+    );
+    if (!this._features.length) {
+      return { rows: [] };
+    }
+    assert2(
+      typeof aggregations !== "string",
+      "Unsupported tileset SQL aggregation"
+    );
+    const result = {};
+    const usedAliases = /* @__PURE__ */ new Set();
+    for (const { column, operation: operation2, alias } of aggregations) {
+      if (column && column !== "*" || operation2 !== AggregationTypes.Count) {
+        assertColumn(this._features, column);
+      }
+      const aliasKey = alias.toLowerCase();
+      assert2(!usedAliases.has(aliasKey), `Duplicate alias: ${aliasKey}`);
+      usedAliases.add(aliasKey);
+      const targetOperation = aggregationFunctions[operation2];
+      assert2(targetOperation, `Unsupported operation: ${operation2}`);
+      result[alias] = targetOperation(filteredFeatures, column);
+    }
+    return { rows: [result] };
+  }
   /** @experimental */
   async getExtent() {
     return Promise.reject(new Error("not implemented"));
@@ -7824,6 +7883,16 @@ var WidgetTilesetSource = class extends WidgetSource {
   }) {
     return this._executeWorkerMethod("getRange" /* GET_RANGE */, [options], signal);
   }
+  async getAggregations({
+    signal,
+    ...options
+  }) {
+    return this._executeWorkerMethod(
+      "getAggregations" /* GET_AGGREGATIONS */,
+      [options],
+      signal
+    );
+  }
   /** @experimental */
   async getExtent() {
     return Promise.resolve({
@@ -8177,6 +8246,102 @@ var vectorTilesetSource = async function(options) {
   );
 };
 
+// src/sources/trajectory-query-source.ts
+var trajectoryQuerySource = async function(options) {
+  const {
+    columns,
+    spatialDataColumn = DEFAULT_GEO_COLUMN,
+    sqlQuery,
+    tileResolution = DEFAULT_TILE_RESOLUTION,
+    queryParameters,
+    aggregationExp,
+    trajectoryIdColumn,
+    timestampColumn
+  } = options;
+  const spatialDataType = "trajectory";
+  const urlParameters = {
+    spatialDataColumn,
+    spatialDataType,
+    tileResolution: tileResolution.toString(),
+    q: sqlQuery,
+    trajectoryIdColumn,
+    timestampColumn
+  };
+  if (columns) {
+    urlParameters.columns = columns.join(",");
+  }
+  if (queryParameters) {
+    urlParameters.queryParameters = queryParameters;
+  }
+  if (aggregationExp) {
+    urlParameters.aggregationExp = aggregationExp;
+  }
+  const result = await baseSource(
+    "query",
+    options,
+    urlParameters
+  );
+  const widgetSource = new WidgetQuerySource({
+    ...options,
+    // NOTE: Parameters with default values above must be explicitly passed here.
+    spatialDataColumn,
+    spatialDataType,
+    tileResolution
+  });
+  const timestampRange = await widgetSource.getRange({ column: timestampColumn });
+  return {
+    ...result,
+    widgetSource,
+    timestampRange
+  };
+};
+
+// src/sources/trajectory-table-source.ts
+var trajectoryTableSource = async function(options) {
+  const {
+    columns,
+    spatialDataColumn = DEFAULT_GEO_COLUMN,
+    tableName,
+    tileResolution = DEFAULT_TILE_RESOLUTION,
+    aggregationExp,
+    trajectoryIdColumn,
+    timestampColumn
+  } = options;
+  const spatialDataType = "trajectory";
+  const urlParameters = {
+    name: tableName,
+    spatialDataColumn,
+    spatialDataType,
+    tileResolution: tileResolution.toString(),
+    trajectoryIdColumn,
+    timestampColumn
+  };
+  if (columns) {
+    urlParameters.columns = columns.join(",");
+  }
+  if (aggregationExp) {
+    urlParameters.aggregationExp = aggregationExp;
+  }
+  const result = await baseSource(
+    "table",
+    options,
+    urlParameters
+  );
+  const widgetSource = new WidgetTableSource({
+    ...options,
+    // NOTE: Parameters with default values above must be explicitly passed here.
+    spatialDataColumn,
+    spatialDataType,
+    tileResolution
+  });
+  const timestampRange = await widgetSource.getRange({ column: timestampColumn });
+  return {
+    ...result,
+    widgetSource,
+    timestampRange
+  };
+};
+
 // src/api/query.ts
 var query = async function(options) {
   const {
@@ -8335,250 +8500,6 @@ 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;
@@ -9157,37 +9078,6 @@ 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 = {
@@ -9204,19 +9094,7 @@ 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",
@@ -9249,12 +9127,6 @@ var sharedPropMap = {
     wireframe: "wireframe"
   }
 };
-var rasterPropsMap = {
-  isVisible: "visible",
-  visConfig: {
-    opacity: "opacity"
-  }
-};
 var customMarkersPropsMap = {
   color: "getIconColor",
   visConfig: {
@@ -9298,12 +9170,6 @@ 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);
@@ -9324,19 +9190,16 @@ 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 "global" in attribute.quantiles ? attribute.quantiles.global[scaleLength] : attribute.quantiles[scaleLength];
+    return attribute.quantiles.global ? attribute.quantiles.global[scaleLength] : attribute.quantiles[scaleLength];
   }
   let { min: min2 } = attribute;
   if (scaleType === "log" && min2 === 0) {
     min2 = 1e-5;
   }
-  return [min2 ?? 0, attribute.max ?? 1];
+  return [min2, attribute.max];
 }
 function domainFromValues(values, scaleType) {
   if (scaleType === "ordinal" || scaleType === "point") {
@@ -9357,14 +9220,12 @@ function calculateDomain(data, name, scaleType, scaleLength) {
   if (data.tilestats) {
     const { attributes } = data.tilestats.layers[0];
     const attribute = attributes.find((a) => a.attribute === name);
-    if (attribute) {
-      return domainFromAttribute(attribute, scaleType, scaleLength);
-    }
+    return domainFromAttribute(attribute, scaleType, scaleLength);
   }
   return [0, 1];
 }
 function normalizeAccessor(accessor, data) {
-  if (data.features || data.tilestats || data.raster_metadata) {
+  if (data.features || data.tilestats) {
     return (object, info) => {
       if (object) {
         return accessor(object.properties || object.__source.object.properties);
@@ -9397,75 +9258,46 @@ function findAccessorKey(keys, properties) {
   return keys;
 }
 function getColorAccessor({ name, colorColumn }, scaleType, { aggregation, range }, opacity, data) {
-  const { scale: scale2, domain } = calculateLayerScale(
+  const scale2 = calculateLayerScale(
     colorColumn || name,
-    colorColumn ? "identity" : scaleType,
+    scaleType,
     range,
     data
   );
   const alpha = opacityToAlpha(opacity);
-  let accessorKeys = getAccessorKeys(colorColumn || name, aggregation);
+  let accessorKeys = getAccessorKeys(name, aggregation);
   const accessor = (properties) => {
     if (!(accessorKeys[0] in properties)) {
       accessorKeys = findAccessorKey(accessorKeys, properties);
     }
     const propertyValue = properties[accessorKeys[0]];
-    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)
+    const { r, g, b } = rgb(scale2(propertyValue));
+    return [r, g, b, propertyValue === null ? 0 : alpha];
   };
+  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 === "custom") {
-    domain = calculateDomain(data, name, scaleType, colors.length);
-    const [min2, max2] = domain;
-    if (range.uiCustomScaleType === "logarithmic") {
-      scaleDomain = getLog10ScaleSteps({
-        min: min2,
-        max: max2,
-        steps: colors.length
-      });
-      scaleColor = colors;
-    } else if (range.colorMap) {
-      const { colorMap } = range;
-      scaleDomain = [];
+  if (scaleType !== "identity") {
+    const { colorMap, colors } = range;
+    if (Array.isArray(colorMap)) {
       colorMap.forEach(([value, color2]) => {
-        scaleDomain.push(Number(value));
+        domain.push(value);
         scaleColor.push(color2);
       });
+    } else {
+      domain = calculateDomain(data, name, scaleType, colors.length);
+      scaleColor = colors;
     }
-  } else if (scaleType !== "identity") {
-    domain = calculateDomain(data, name, scaleType, colors.length);
-    scaleColor = colors;
     if (scaleType === "ordinal") {
       domain = domain.slice(0, scaleColor.length);
     }
   }
-  return {
-    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(range);
-  scale2.unknown(unknown);
+  scale2.range(scaleColor);
+  scale2.unknown(UNKNOWN_COLOR);
   return scale2;
 }
 var FALLBACK_ICON = "data:image/svg+xml;charset=utf-8;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMTAwIDEwMCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4NCiAgPGNpcmNsZSBjeD0iNTAiIGN5PSI1MCIgcj0iNTAiLz4NCjwvc3ZnPg==";
@@ -9515,13 +9347,9 @@ function negateAccessor(accessor) {
 }
 function getSizeAccessor({ name }, scaleType, aggregation, range, data) {
   const scale2 = scaleType ? SCALE_FUNCS[scaleType]() : identity2;
-  let domain = [];
-  if (scaleType && range) {
+  if (scaleType) {
     if (aggregation !== AggregationTypes.Count) {
-      domain = calculateDomain(data, name, scaleType);
-      scale2.domain(domain);
-    } else {
-      domain = scale2.domain();
+      scale2.domain(calculateDomain(data, name, scaleType));
     }
     scale2.range(range);
   }
@@ -9533,12 +9361,7 @@ function getSizeAccessor({ name }, scaleType, aggregation, range, data) {
     const propertyValue = properties[accessorKeys[0]];
     return scale2(propertyValue);
   };
-  return {
-    accessor: normalizeAccessor(accessor, data),
-    domain,
-    scaleDomain: domain,
-    range
-  };
+  return { accessor: normalizeAccessor(accessor, data), scale: scale2 };
 }
 var FORMATS = {
   date: formatDate,
@@ -9589,420 +9412,13 @@ 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/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 mapConfig = keplerMapConfig.config;
-  const { mapState, mapStyle, popupSettings, legendSettings, visState } = mapConfig;
-  const { layers } = visState;
-  const layersReverse = [...layers].reverse();
+  const config2 = keplerMapConfig.config;
+  const { filters, mapState, mapStyle, popupSettings, legendSettings } = config2;
+  const { layers, layerBlending, interactionConfig } = config2.visState;
   return {
     id: json.id,
     title: json.title,
@@ -10015,19 +9431,45 @@ function parseMap(json) {
     popupSettings,
     legendSettings,
     token,
-    layers: layersReverse.map((layer) => {
+    layers: layers.reverse().map(({ id, type, config: config3, visualChannels }) => {
       try {
-        const { dataId } = layer.config;
+        const { dataId } = config3;
         const dataset = datasets.find(
           (d) => d.id === dataId
         );
         assert2(dataset, `No dataset matching dataId: ${dataId}`);
-        const layerDescriptor = getLayerDescriptor({
-          mapConfig,
-          layer,
+        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,
           dataset
-        });
-        return layerDescriptor;
+        );
+        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;
       } catch (e) {
         console.error(e.message);
         return void 0;
@@ -10092,63 +9534,43 @@ 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) {
-  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 {
+    colorField,
+    colorScale,
+    radiusField,
+    radiusScale,
+    strokeColorField,
+    strokeColorScale,
+    weightField
+  } = visualChannels;
+  const { heightField, heightScale } = visualChannels;
   const { textLabel, visConfig } = config2;
   const result = {};
-  const updateTriggers = {};
   const scales = {};
-  {
-    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 (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 = {};
   }
   if (layerType === "clusterTile") {
     const aggregationExpAlias = getDefaultAggregationExpColumnAliasForLayerType(
@@ -10161,7 +9583,6 @@ 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,
@@ -10170,16 +9591,11 @@ 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,
@@ -10196,107 +9612,68 @@ function createChannelProps(id, layerType, config2, visualChannels, data, datase
       );
       return calculateClusterTextFontSize(radius);
     };
-    updateTriggers.getTextSize = {
-      aggregationExpAlias,
-      radiusRange: visConfig.radiusRange
-    };
   }
-  {
-    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
-      };
-    }
-  }
-  {
-    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 (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)
+    };
   }
-  {
-    const { sizeField: strokeWidthField, sizeScale: strokeWidthScale } = visualChannels;
-    const { sizeRange, sizeAggregation } = visConfig;
-    if (strokeWidthField && sizeRange) {
-      const { accessor, ...scaleProps } = getSizeAccessor(
-        strokeWidthField,
-        strokeWidthScale,
-        sizeAggregation,
-        sizeRange,
-        data
-      );
-      result.getLineWidth = accessor;
-      scales.lineWidth = updateTriggers.getLineWidth = {
-        field: strokeWidthField,
-        type: strokeWidthScale || "identity",
-        ...scaleProps
-      };
-    }
+  if (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 { enable3d, heightRange } = visConfig;
-    const { heightField, heightScale } = visualChannels;
-    if (heightField && heightRange && enable3d) {
-      const { accessor, ...scaleProps } = getSizeAccessor(
-        heightField,
-        heightScale,
-        visConfig.heightAggregation,
-        heightRange,
-        data
-      );
-      result.getElevation = accessor;
-      scales.elevation = updateTriggers.getElevation = {
-        field: heightField,
-        type: heightScale || "identity",
-        ...scaleProps
-      };
-    }
+  if (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 { 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 (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)
+    };
   }
   if (visConfig.customMarkers) {
     const maxIconSize = getMaxMarkerSize(visConfig, visualChannels);
@@ -10313,12 +9690,6 @@ function createChannelProps(id, layerType, config2, visualChannels, data, datase
       { fallbackUrl: customMarkersUrl, maxIconSize, useMaskedIcons },
       data
     );
-    updateTriggers.getIcon = {
-      customMarkersUrl,
-      customMarkersRange,
-      maxIconSize,
-      useMaskedIcons
-    };
     result._subLayerProps = {
       "points-icon": {
         loadOptions: {
@@ -10335,11 +9706,9 @@ 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(
@@ -10350,7 +9719,6 @@ function createChannelProps(id, layerType, config2, visualChannels, data, datase
         data
       );
       result.getIconAngle = negateAccessor(accessor);
-      updateTriggers.getIconAngle = updateTriggers.getRotationField;
     }
   } else if (layerType === "tileset") {
     result.pointType = "circle";
@@ -10395,13 +9763,7 @@ function createChannelProps(id, layerType, config2, visualChannels, data, datase
       }
     };
   }
-  return {
-    channelProps: {
-      ...result,
-      updateTriggers
-    },
-    scales
-  };
+  return { channelProps: result, scales };
 }
 function createLoadOptions(accessToken) {
   return {
@@ -11048,16 +10410,9 @@ export {
   WidgetSource,
   WidgetTableSource,
   WidgetTilesetSource,
-  ErrorCode as _ErrorCode,
-  applyLayerGroupFilters as _applyLayerGroupFilters,
   _buildFeatureFilter,
-  createVecExprEvaluator as _createVecExprEvaluator,
   domainFromValues as _domainFromValues,
-  evaluateVecExpr as _evaluateVecExpr,
   _getHexagonResolution,
-  getLog10ScaleSteps as _getLog10ScaleSteps,
-  getRasterTileLayerStyleProps as _getRasterTileLayerStyleProps,
-  validateVecExprSyntax as _validateVecExprSyntax,
   addFilter,
   aggregate,
   aggregationFunctions,
@@ -11070,11 +10425,9 @@ export {
   buildStatsUrl,
   calculateClusterRadius,
   calculateClusterTextFontSize,
-  calculateLayerScale,
   clearDefaultRequestCache,
   clearFilters,
   configureSource,
-  createColorScale,
   createPolygonSpatialFilter,
   createViewportSpatialFilter,
   fetchBasemapProps,
@@ -11089,7 +10442,6 @@ export {
   getDefaultAggregationExpColumnAliasForLayerType,
   getFilter,
   getIconUrlAccessor,
-  getLayerDescriptor,
   getLayerProps,
   getMaxMarkerSize,
   getSizeAccessor,
@@ -11120,6 +10472,8 @@ export {
   tileFeatures,
   tileFeaturesGeometries,
   tileFeaturesSpatialIndex,
+  trajectoryQuerySource,
+  trajectoryTableSource,
   transformToTileCoords,
   vectorQuerySource,
   vectorTableSource,