leaflet-city-mapper 0.0.5 → 0.0.7

package/src/sources/buildAreaFeature.js

@@ -1,45 +1,26 @@
-import { L } from '../globals/L.js';
-import { buildAreaPoint } from './buildAreaPoint.js';
-import { buildAreaPolygon } from '../geometry/buildExtrudedPolygon.js';
 import { parseColor } from '../colors/parseColor.js';
 import { featureAnchor } from './featureAnchor.js';
 import { extrusionStyle } from './extrusionStyle.js';
 import { prepareAreaGeometryJob } from './prepareAreaGeometryJob.js';
+import { matchesAreaTile } from './matchesAreaTile.js';
 
 export function buildAreaFeature(context, feature) {
   const { backend: layer, area, map } = context;
   const coords = area.coords;
   const coordinates = featureAnchor(feature, layer.options.nightLight);
-  const geometry = feature.geometry, isTree = geometry.type === 'Point';
+  const geometry = feature.geometry;
   const lon = coordinates[0], lat = coordinates[1];
-  if (coords) {
-    const anchor = map.project(/* alloc */ new L.LatLng(lat, lon), coords.z);
-    if (Math.floor(anchor.x / 256) !== coords.x || Math.floor(anchor.y / 256) !== coords.y) return;
-  }
+  if (!matchesAreaTile(map, coords, lon, lat)) return;
   const style = extrusionStyle(layer, feature);
   if (style === null) {
     context.skipped++;
     return;
   }
-  const { top, bottom = 0, color = 0xd9b38c } = style;
+  const { color = 0xd9b38c } = style;
   const baseColor = parseColor(color);
-  if (context.jobs) {
-    prepareAreaGeometryJob(context, feature, lon, lat, style, baseColor);
-    context.featureFaces.push(/* alloc */ {
-      id: feature.id ?? feature.properties?.objectid ?? JSON.stringify(geometry),
-      properties: feature.properties, baseColor,
-    });
-    return;
-  }
-  const vertexStart = context.positions.length / 3;
-  if (isTree) buildAreaPoint(context, feature, lon, lat, style, baseColor);
-  let polygon;
-  if (geometry.type === 'Polygon') buildAreaPolygon(context, geometry.coordinates, top, bottom, baseColor);
-  else if (geometry.type === 'MultiPolygon') for (polygon of geometry.coordinates) buildAreaPolygon(context, polygon, top, bottom, baseColor);
-  const vertexEnd = context.positions.length / 3;
+  prepareAreaGeometryJob(context, feature, lon, lat, style, baseColor);
   context.featureFaces.push(/* alloc */ {
     id: feature.id ?? feature.properties?.objectid ?? JSON.stringify(geometry),
     properties: feature.properties, baseColor,
-    faceStart: vertexStart / 3, faceEnd: vertexEnd / 3, vertexStart, vertexEnd,
   });
 }

package/src/sources/buildAreaFeatures.js

@@ -0,0 +1,14 @@
+import { buildAreaFeature } from './buildAreaFeature.js';
+
+export async function buildAreaFeatures(context, area, features) {
+  let deadline = performance.now() + 4, feature;
+  for (feature of features) {
+    if (area.request.signal.aborted) return;
+    if (performance.now() >= deadline) {
+      await /* alloc */ new Promise(requestAnimationFrame);
+      if (area.request.signal.aborted) return;
+      deadline = performance.now() + 4;
+    }
+    buildAreaFeature(context, feature);
+  }
+}

package/src/sources/initVectorTiles.js

@@ -0,0 +1,15 @@
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+import { readyByLayer } from '../weakmaps/readyByLayer.js';
+import { configureVectorTileLayer } from '../vector-tiles/configureVectorTileLayer.js';
+import { readyVectorTiles } from './readyVectorTiles.js';
+import { reportError } from '../raster/reportRasterError.js';
+import { noOperation } from '../utils/noOperation.js';
+
+export function initVectorTiles(layer, options) {
+  kindByLayer.set(layer, 'pending');
+  const ready = configureVectorTileLayer(layer, options)
+    .then(readyVectorTiles.bind(null, layer))
+    .catch(reportError.bind(null, layer));
+  readyByLayer.set(layer, ready);
+  ready.catch(noOperation);
+}

package/src/sources/isVectorTileSource.js

@@ -0,0 +1,4 @@
+export function isVectorTileSource(options) {
+  return options.data === undefined && (options.tileJSON !== undefined ||
+    typeof options.url === 'string' && /\{[zxy]\}|%7B[zxy]%7D/i.test(options.url));
+}

package/src/sources/matchesAreaTile.js

@@ -0,0 +1,7 @@
+import { L } from '../globals/L.js';
+
+export function matchesAreaTile(map, coords, lon, lat) {
+  if (!coords) return true;
+  const anchor = map.project(/* alloc */ new L.LatLng(lat, lon), coords.z);
+  return Math.floor(anchor.x / 256) === coords.x && Math.floor(anchor.y / 256) === coords.y;
+}

package/src/sources/prepareAreaGeometryJob.js

@@ -1,19 +1,10 @@
 import { projectedTree } from '../projections/projectTreePoint.js';
-import { projectRing } from '../projections/projectRing.js';
 import { parseColor } from '../colors/parseColor.js';
+import { projectAreaPolygons } from './projectAreaPolygons.js';
 
 export function prepareAreaGeometryJob(context, feature, lon, lat, style, baseColor) {
   const geometry = feature.geometry;
-  const polygons = /* alloc */ [];
-  const rings = geometry.type === 'Polygon' ? /* alloc */ [geometry.coordinates]
-    : geometry.type === 'MultiPolygon' ? geometry.coordinates : /* alloc */ [];
-  let polygon, ring, paths;
-  for (polygon of rings) {
-    if (!polygon.length) throw /* alloc */ new Error('Empty GeoJSON polygon');
-    paths = /* alloc */ [];
-    for (ring of polygon) paths.push(projectRing(context, ring));
-    polygons.push(paths);
-  }
+  const polygons = projectAreaPolygons(context, geometry);
   const point = geometry.type === 'Point' ? projectedTree(context, lon, lat) : null;
   const nightLight = context.backend.options.nightLight;
   const crownColor = point ? parseColor(style.color ?? (nightLight ? undefined : 0x4f823b)) : baseColor;

package/src/sources/projectAreaPolygons.js

@@ -0,0 +1,15 @@
+import { projectRing } from '../projections/projectRing.js';
+
+export function projectAreaPolygons(context, geometry) {
+  const rings = geometry.type === 'Polygon' ? /* alloc */ [geometry.coordinates]
+    : geometry.type === 'MultiPolygon' ? geometry.coordinates : /* alloc */ [];
+  const polygons = /* alloc */ [];
+  let polygon, ring, paths;
+  for (polygon of rings) {
+    if (!polygon.length) throw /* alloc */ new Error('Empty GeoJSON polygon');
+    paths = /* alloc */ [];
+    for (ring of polygon) paths.push(projectRing(context, ring));
+    polygons.push(paths);
+  }
+  return polygons;
+}

package/src/sources/readyVectorTiles.js

@@ -0,0 +1,10 @@
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+
+export function readyVectorTiles(layer) {
+  const map = layer._map;
+  map?.removeLayer(layer);
+  kindByLayer.delete(layer);
+  map?.addLayer(layer);
+  layer.fire('ready');
+  return layer;
+}

package/src/sources/sourceAreaContext.js

@@ -8,13 +8,8 @@ export function sourceAreaContext(layer, area, map) {
   return /* alloc */ {
     backend: layer, area, map, crs, origin,
     metres: Math.cos(locationByLayer.get(layer).lat * radians),
-    positions: /* alloc */ [],
-    normals: /* alloc */ [],
-    colors: /* alloc */ [],
-    uvs: /* alloc */ [],
+    jobs: /* alloc */ [],
     featureFaces: /* alloc */ [],
-    lights: /* alloc */ [],
-    supports: /* alloc */ new Set(),
     skipped: 0,
   };
 }

package/src/sunlight/createSun.js

@@ -38,7 +38,6 @@ export function createSun(map) {
   status.setAttribute('role', 'status');
   const note = document.createElement('small');
   note.style.color = '#555';
-  note.textContent = 'Indicative · loaded geometry only. Streetlight illumination is estimated, not measured lux.';
   container.append(date, slider, timeRow, status, note);
   const state = /* alloc */ {
     control: null, map, originalSky: '', container, sunDisc, moonDisc, date, slider, output, status,

package/src/terrain/initTerrain.js

@@ -3,6 +3,7 @@ import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
 import { terrainReadyByLayer } from '../weakmaps/terrainReadyByLayer.js';
 import { terrainSourceByLayer } from '../weakmaps/terrainSourceByLayer.js';
 import { terrainTilesByLayer } from '../weakmaps/terrainTilesByLayer.js';
+import { streamTerrainByLayer } from '../weakmaps/streamTerrainByLayer.js';
 
 
 
@@ -12,10 +13,14 @@ import { init3D } from '../scene/init3D.js';
 
 /**
  * Renders Float32 DEM tiles and archived raster basemaps in the shared WebGPU scene.
- * Source options: `url` (single-zoom Float32 PMTiles or supported COG DEM);
+ * Source options: `url` (single-zoom Float32 PMTiles or supported COG DEM),
+ * or `getTile(z, x, y, signal)` for streamed 256px Float32 elevations;
  * `bridges` (optional GeoJSON deck polygons with Z, see _addBridges).
  */
 export function initTerrain(layer, options) {
+  if (options.getTile !== undefined && typeof options.getTile !== 'function') {
+    throw /* alloc */ new Error('Streamed terrain requires a getTile function');
+  }
   const terrainSource = options.url;
   const layerOptions = /* alloc */ { ...options };
   delete layerOptions.url;
@@ -24,5 +29,6 @@ export function initTerrain(layer, options) {
   terrainTilesByLayer.set(layer, /* alloc */ new Map());
   rasterTilesByLayer.set(layer, /* alloc */ new Map());
   terrainReadyByLayer.set(layer, false);
+  if (options.getTile) streamTerrainByLayer.set(layer, true);
   kindByLayer.set(layer, 'terrain');
 }

package/src/terrain/loadTerrain.js

@@ -5,6 +5,7 @@ import { terrainControllerByLayer } from '../weakmaps/terrainControllerByLayer.j
 import { terrainLoadingByLayer } from '../weakmaps/terrainLoadingByLayer.js';
 import { terrainReadyByLayer } from '../weakmaps/terrainReadyByLayer.js';
 import { terrainSourceByLayer } from '../weakmaps/terrainSourceByLayer.js';
+import { workerMapByLayer } from '../weakmaps/workerMapByLayer.js';
 
 import { createLayer } from '../scene/createLayer.js';
 
@@ -23,9 +24,11 @@ export async function loadTerrain(layer) {
   try {
     if (!terrainSourceByLayer.get(layer)) throw /* alloc */ new Error('Terrain layer requires a PMTiles or COG elevation archive');
     const archive = createLayer(/* alloc */ { source: /* alloc */ {
-      type: layer.options.asset !== undefined || /\.tiff?(?:[?#]|$)/i.test(terrainSourceByLayer.get(layer)) ? 'cog' : 'pmtiles',
+      type: 'raster',
       url: terrainSourceByLayer.get(layer), archive: layer.options.archive, asset: layer.options.asset,
+      workerUrl: layer.options.workerUrl,
     } });
+    workerMapByLayer.set(archive, layer._map);
     terrainArchiveByLayer.set(layer, archive);
     await readyByLayer.get(archive);
     const header = headerByLayer.get(archive);

package/src/terrain/mapElevationOf.js

@@ -1,7 +1,11 @@
 import { terrain3DByMap } from '../weakmaps/terrain3DByMap.js';
+import { streamTerrainByMap } from '../weakmaps/streamTerrainByMap.js';
 import { getElevation } from './getElevation.js';
+import { gridTerrainElevation } from '../native/gridTerrainElevation.js';
 
 export function mapElevationOf(map, location) {
   const terrain = terrain3DByMap.get(map);
-  return terrain && getElevation(terrain, location);
+  if (terrain) return getElevation(terrain, location);
+  const stream = streamTerrainByMap.get(map);
+  return stream && gridTerrainElevation(stream, location);
 }

package/src/terrain/onTerrainAdd.js

@@ -1,6 +1,8 @@
 import { rootByLayer } from '../weakmaps/rootByLayer.js';
 import { terrainPromiseByLayer } from '../weakmaps/terrainPromiseByLayer.js';
 import { terrain3DByMap } from '../weakmaps/terrain3DByMap.js';
+import { streamTerrainByMap } from '../weakmaps/streamTerrainByMap.js';
+import { streamTerrainByLayer } from '../weakmaps/streamTerrainByLayer.js';
 
 
 
@@ -13,9 +15,17 @@ import { setLayerTerrain } from './setLayerTerrain.js';
 
 export function onTerrainAdd(layer, map) {
 
-  if (terrain3DByMap.get(map) && terrain3DByMap.get(map) !== layer) {
+  if (streamTerrainByMap.get(map) || terrain3DByMap.get(map) && terrain3DByMap.get(map) !== layer) {
     throw /* alloc */ new Error('Only one terrain layer can be active per map');
   }
+  if (streamTerrainByLayer.get(layer)) {
+    streamTerrainByMap.set(map, /* alloc */ {
+      layer, map, terrainCache: /* alloc */ new Map(), terrainController: /* alloc */ new AbortController(),
+    });
+    onAdd3DLayer(layer, map);
+    map.fire('terrainchange');
+    return;
+  }
   terrain3DByMap.set(map, layer);
   onAdd3DLayer(layer, map);
   if (rootByLayer.get(layer)) terrainPromiseByLayer.set(layer, loadTerrain(layer));

package/src/terrain/onTerrainRemove.js

@@ -11,6 +11,7 @@ import { terrainPromiseByLayer } from '../weakmaps/terrainPromiseByLayer.js';
 import { terrainReadyByLayer } from '../weakmaps/terrainReadyByLayer.js';
 import { terrainTilesByLayer } from '../weakmaps/terrainTilesByLayer.js';
 import { terrain3DByMap } from '../weakmaps/terrain3DByMap.js';
+import { streamTerrainByMap } from '../weakmaps/streamTerrainByMap.js';
 
 
 import { renderEmpty } from '../globals/renderEmpty.js';
@@ -25,7 +26,15 @@ import { onRemove3DLayer } from '../scene/onRemove3DLayer.js';
 import { clearLayerTerrain } from './clearLayerTerrain.js';
 
 export function onTerrainRemove(layer, map) {
-
+  const stream = streamTerrainByMap.get(map);
+  if (stream?.layer === layer) {
+    streamTerrainByMap.delete(map);
+    stream.terrainController.abort();
+    stream.terrainCache.clear();
+    map.fire('terrainchange');
+    onRemove3DLayer(layer, map);
+    return;
+  }
   terrainControllerByLayer.get(layer)?.abort();
   terrainLoadingByLayer.set(layer, false);
   terrainReadyByLayer.set(layer, false);

package/src/utils/yieldTask.js

@@ -0,0 +1,5 @@
+export function yieldTask(delay = 0) {
+  const task = Promise.withResolvers();
+  setTimeout(task.resolve, delay);
+  return task.promise;
+}

package/src/vector-style/appendQuotedStyleCharacter.js

@@ -0,0 +1,22 @@
+export function appendQuotedStyleCharacter(char, state) {
+  if (state.quoted) {
+    if (state.escaped) {
+      state.escaped = false;
+      return char === "'" ? char : '\\' + char;
+    }
+    if (char === '\\') {
+      state.escaped = true;
+      return '';
+    }
+    if (char === state.quoted) {
+      state.quoted = '';
+      return '"';
+    }
+    return char === '"' ? '\\"' : char;
+  }
+  if (char === '"' || char === "'") {
+    state.quoted = char;
+    return '"';
+  }
+  return undefined;
+}

package/src/vector-style/arrayContainsRange.js

@@ -0,0 +1,8 @@
+export function arrayContainsRange(values, start, end, target) {
+  let i = 0, value = null;
+  for (i = start; i < end; i++) {
+    value = values[i];
+    if (value === target || (value !== value && target !== target)) return true;
+  }
+  return false;
+}

package/src/vector-style/evaluateBoolean.js

@@ -0,0 +1,18 @@
+import { evaluateStyle } from './evaluateStyle.js';
+
+export function evaluateBoolean(op, args, properties, zoom, legacy) {
+  let i = 0;
+  if (op === 'all') {
+    for (i = 0; i < args.length; i++) {
+      if (!evaluateStyle(args[i], properties, zoom, legacy)) return false;
+    }
+    return true;
+  }
+  if (op === 'any') {
+    for (i = 0; i < args.length; i++) {
+      if (evaluateStyle(args[i], properties, zoom, legacy)) return true;
+    }
+    return false;
+  }
+  throw /* alloc */ new Error(`Unsupported vector style expression: ${op}`);
+}

package/src/vector-style/evaluateCoalesceOrCase.js

@@ -0,0 +1,21 @@
+import { evaluateStyle } from './evaluateStyle.js';
+
+export function evaluateCoalesceOrCase(op, args, properties, zoom, legacy) {
+  let i = 0, result = null;
+  if (op === 'coalesce') {
+    for (i = 0; i < args.length; i++) {
+      result = evaluateStyle(args[i], properties, zoom);
+      if (result !== null && result !== undefined) return result;
+    }
+    return null;
+  }
+  if (op === 'case') {
+    for (i = 0; i < args.length - 1; i += 2) {
+      if (evaluateStyle(args[i], properties, zoom)) {
+        return evaluateStyle(args[i + 1], properties, zoom);
+      }
+    }
+    return evaluateStyle(args[args.length - 1], properties, zoom);
+  }
+  throw /* alloc */ new Error(`Unsupported vector style expression: ${op}`);
+}

package/src/vector-style/evaluateComparison.js

@@ -0,0 +1,16 @@
+import { evaluateInput } from './evaluateInput.js';
+import { evaluateStyle } from './evaluateStyle.js';
+
+export function evaluateComparison(op, args, properties, zoom, legacy) {
+  const left = evaluateInput(args[0], properties, zoom, legacy);
+  const right = evaluateStyle(args[1], properties, zoom);
+  switch (op) {
+    case '==': return left === right;
+    case '!=': return left !== right;
+    case '<=': return left <= right;
+    case '>=': return left >= right;
+    case '<': return left < right;
+    case '>': return left > right;
+      default: throw /* alloc */ new Error(`Unsupported vector style expression: ${op}`);
+  }
+}

package/src/vector-style/evaluateIExpression.js

@@ -0,0 +1,8 @@
+import { evaluateInterpolate } from './evaluateInterpolate.js';
+import { evaluateMembership } from './evaluateMembership.js';
+
+export function evaluateIExpression(op, args, properties, zoom, legacy) {
+  if (op === 'in') return evaluateMembership(op, args, properties, zoom, legacy);
+  if (op === 'interpolate') return evaluateInterpolate(args, properties, zoom);
+  throw /* alloc */ new Error(`Unsupported vector style expression: ${op}`);
+}

package/src/vector-style/evaluateInput.js

@@ -0,0 +1,6 @@
+import { evaluateStyle } from './evaluateStyle.js';
+
+export function evaluateInput(value, properties, zoom, legacy) {
+  if (legacy && typeof value === 'string') return properties[value];
+  return evaluateStyle(value, properties, zoom);
+}

package/src/vector-style/evaluateInterpolate.js

@@ -0,0 +1,27 @@
+import { styleColor } from './styleColor.js';
+import { evaluateStyle } from './evaluateStyle.js';
+
+export function evaluateInterpolate(args, properties, zoom) {
+  const result = evaluateStyle(args[1], properties, zoom);
+  const base = args[0][0] === 'exponential' ? args[0][1] : 1;
+  let i = 0, lower = 0, upper = 0, ratio = 0, left = null, right = null, j = 0, color = '';
+  if (result <= args[2]) return evaluateStyle(args[3], properties, zoom);
+  for (i = 4; i < args.length; i += 2) {
+    if (result > args[i]) continue;
+    lower = args[i - 2];
+    upper = args[i];
+    ratio = base === 1 ? (result - lower) / (upper - lower)
+      : (base ** (result - lower) - 1) / (base ** (upper - lower) - 1);
+    left = evaluateStyle(args[i - 1], properties, zoom);
+    right = evaluateStyle(args[i + 1], properties, zoom);
+    if (typeof left === 'number' && typeof right === 'number') return left + (right - left) * ratio;
+    left = styleColor(left);
+    right = styleColor(right);
+    for (j = 0; j < 3; j++) {
+      if (j) color += ',';
+      color += Math.round(left[j] + (right[j] - left[j]) * ratio);
+    }
+    return `rgba(${color},${left[3] + (right[3] - left[3]) * ratio})`;
+  }
+  return evaluateStyle(args.at(-1), properties, zoom);
+}

package/src/vector-style/evaluateMatch.js

@@ -0,0 +1,12 @@
+import { evaluateStyle } from './evaluateStyle.js';
+
+export function evaluateMatch(args, properties, zoom) {
+  const result = evaluateStyle(args[0], properties, zoom);
+  let i = 0, matched = false;
+  for (i = 1; i < args.length - 1; i += 2) {
+    if (Array.isArray(args[i])) matched = args[i].includes(result);
+    else matched = args[i] === result;
+    if (matched) return evaluateStyle(args[i + 1], properties, zoom);
+  }
+  return evaluateStyle(args[args.length - 1], properties, zoom);
+}

package/src/vector-style/evaluateMath.js

@@ -0,0 +1,14 @@
+import { evaluateStyle } from './evaluateStyle.js';
+
+export function evaluateMath(op, args, properties, zoom) {
+  let i = 0, sum = 0;
+  if (op === '+') {
+    for (i = 0; i < args.length; i++) sum += evaluateStyle(args[i], properties, zoom);
+    return sum;
+  }
+  if (op === '-') {
+    if (args.length === 1) return -evaluateStyle(args[0], properties, zoom);
+    return evaluateStyle(args[0], properties, zoom) - evaluateStyle(args[1], properties, zoom);
+  }
+  throw /* alloc */ new Error(`Unsupported vector style expression: ${op}`);
+}

package/src/vector-style/evaluateMembership.js

@@ -0,0 +1,18 @@
+import { arrayContainsRange } from './arrayContainsRange.js';
+import { evaluateInput } from './evaluateInput.js';
+import { evaluateStyle } from './evaluateStyle.js';
+
+export function evaluateMembership(op, args, properties, zoom, legacy) {
+  let target = null;
+  if (op === '!in') {
+    target = evaluateInput(args[0], properties, zoom, legacy);
+    return !arrayContainsRange(args, 1, args.length, target);
+  }
+  if (legacy) {
+    target = evaluateInput(args[0], properties, zoom, true);
+    return arrayContainsRange(args, 1, args.length, target);
+  }
+  const values = evaluateStyle(args[1], properties, zoom);
+  target = evaluateInput(args[0], properties, zoom, false);
+  return values.includes(target);
+}

package/src/vector-style/evaluateNegation.js

@@ -0,0 +1,13 @@
+import { evaluateInput } from './evaluateInput.js';
+import { evaluateMembership } from './evaluateMembership.js';
+import { evaluateStyle } from './evaluateStyle.js';
+
+export function evaluateNegation(op, args, properties, zoom, legacy) {
+  if (op === '!') return !evaluateStyle(args[0], properties, zoom, legacy);
+  if (op === '!=') {
+    return evaluateInput(args[0], properties, zoom, legacy) !==
+      evaluateStyle(args[1], properties, zoom);
+  }
+  if (op === '!in') return evaluateMembership(op, args, properties, zoom, legacy);
+  throw /* alloc */ new Error(`Unsupported vector style expression: ${op}`);
+}

package/src/vector-style/evaluatePrimitive.js

@@ -0,0 +1,9 @@
+export function evaluatePrimitive(op, args, properties, zoom) {
+  switch (op) {
+    case 'literal': return args[0];
+    case 'get': return properties[args[0]];
+    case 'has': return Object.hasOwn(properties, args[0]);
+    case 'zoom': return zoom;
+      default: throw /* alloc */ new Error(`Unsupported vector style expression: ${op}`);
+  }
+}

package/src/vector-style/evaluateStep.js

@@ -0,0 +1,11 @@
+import { evaluateStyle } from './evaluateStyle.js';
+
+export function evaluateStep(args, properties, zoom) {
+  const result = evaluateStyle(args[0], properties, zoom);
+  let output = args[1], i = 0;
+  for (i = 2; i < args.length; i += 2) {
+    if (result < args[i]) break;
+    output = args[i + 1];
+  }
+  return evaluateStyle(output, properties, zoom);
+}

package/src/vector-style/evaluateStyle.js

@@ -0,0 +1,33 @@
+import { evaluateBoolean } from './evaluateBoolean.js';
+import { evaluateCoalesceOrCase } from './evaluateCoalesceOrCase.js';
+import { evaluateComparison } from './evaluateComparison.js';
+import { evaluateIExpression } from './evaluateIExpression.js';
+import { evaluateMath } from './evaluateMath.js';
+import { evaluateMatch } from './evaluateMatch.js';
+import { evaluateNegation } from './evaluateNegation.js';
+import { evaluatePrimitive } from './evaluatePrimitive.js';
+import { evaluateStep } from './evaluateStep.js';
+import { evaluateToExpression } from './evaluateToExpression.js';
+
+export function evaluateStyle(value, properties, zoom, legacy = false) {
+  if (!Array.isArray(value)) return value;
+  const op = value[0];
+  const args = value.slice(1);
+  const operation = String(op);
+  if (/^(?:literal|get|has|zoom)$/.test(operation)) {
+    return evaluatePrimitive(op, args, properties, zoom);
+  }
+  switch (operation[0]) {
+    case 'a': return evaluateBoolean(op, args, properties, zoom, legacy);
+    case '!': return evaluateNegation(op, args, properties, zoom, legacy);
+    case '=':
+    case '<':
+    case '>': return evaluateComparison(op, args, properties, zoom, legacy);
+    case 'i': return evaluateIExpression(op, args, properties, zoom, legacy);
+    case 't': return evaluateToExpression(op, args, properties, zoom, legacy);
+    case 'c': return evaluateCoalesceOrCase(op, args, properties, zoom, legacy);
+    case 'm': return evaluateMatch(args, properties, zoom);
+    case 's': return evaluateStep(args, properties, zoom);
+    default: return evaluateMath(op, args, properties, zoom);
+  }
+}

package/src/vector-style/evaluateToExpression.js

@@ -0,0 +1,14 @@
+import { evaluateStyle } from './evaluateStyle.js';
+
+export function evaluateToExpression(op, args, properties, zoom) {
+  if (op === 'to-boolean') return Boolean(evaluateStyle(args[0], properties, zoom));
+  if (op === 'to-number') {
+    let i = 0, number = 0;
+    for (i = 0; i < args.length; i++) {
+      number = Number(evaluateStyle(args[i], properties, zoom));
+      if (Number.isFinite(number)) return number;
+    }
+    throw /* alloc */ new Error('Invalid numeric style expression');
+  }
+  throw /* alloc */ new Error(`Unsupported vector style expression: ${op}`);
+}

package/src/vector-style/fillVectorPaint.js

@@ -0,0 +1,17 @@
+import { readPaintValue } from './readPaintValue.js';
+import { styleColor } from './styleColor.js';
+
+export function fillVectorPaint(paint, properties, zoom) {
+  const fill = styleColor(readPaintValue(paint, 'fill-color', '#000', properties, zoom));
+  const outline = readPaintValue(paint, 'fill-outline-color', null, properties, zoom);
+  const rgb = outline === null ? null : styleColor(outline);
+  const fillOpacity = readPaintValue(paint, 'fill-opacity', 1, properties, zoom) * fill[3];
+  const fillColor = /* alloc */ { r: fill[0] / 255, g: fill[1] / 255, b: fill[2] / 255 };
+  const color = rgb ? /* alloc */ { r: rgb[0] / 255, g: rgb[1] / 255, b: rgb[2] / 255 } : null;
+  return /* alloc */ {
+    fillColor,
+    fillOpacity,
+    color,
+    weight: 0.5
+  };
+}

package/src/vector-style/lineVectorPaint.js

@@ -0,0 +1,21 @@
+import { readPaintValue } from './readPaintValue.js';
+import { scaleDashArray } from './scaleDashArray.js';
+import { styleColor } from './styleColor.js';
+
+export function lineVectorPaint(layer, paint, properties, zoom) {
+  const weight = readPaintValue(paint, 'line-width', 1, properties, zoom);
+  const rgb = styleColor(readPaintValue(paint, 'line-color', '#000', properties, zoom));
+  const opacity = readPaintValue(paint, 'line-opacity', 1, properties, zoom) * rgb[3];
+  const dashArray = scaleDashArray(paint['line-dasharray'], weight, properties, zoom);
+  const lineCap = layer.layout?.['line-cap'] || 'butt';
+  const lineJoin = layer.layout?.['line-join'] || 'miter';
+  const color = /* alloc */ { r: rgb[0] / 255, g: rgb[1] / 255, b: rgb[2] / 255 };
+  return /* alloc */ {
+    color,
+    opacity,
+    weight,
+    dashArray,
+    lineCap,
+    lineJoin
+  };
+}

package/src/vector-style/parseFunctionalColor.js

@@ -0,0 +1,14 @@
+export function parseFunctionalColor(value) {
+  const match = /^rgba?\(([^)]+)\)$/.exec(value);
+  if (match) {
+    const values = match[1].split(',');
+    let i = 0, finite = true;
+    for (i = 0; i < values.length; i++) values[i] = Number(values[i]);
+    if (values.length === 3) values.push(1);
+    for (i = 0; i < values.length; i++) {
+      if (!Number.isFinite(values[i])) finite = false;
+    }
+    if (values.length === 4 && finite) return values;
+  }
+  throw /* alloc */ new Error(`Unsupported interpolated style color: ${value}`);
+}