leaflet-city-mapper 0.1.0 → 0.1.1

package/src/vector-tiles/createVectorLabel.js

@@ -1,37 +1,37 @@
-import { evaluateStyle } from '../vector-style/evaluateStyle.js';
-import { projectVectorPoint } from './projectVectorPoint.js';
-import { vectorStyleValue } from './vectorStyleValue.js';
-
-/**
- * Construct a projected vector label candidate with evaluated style properties.
- *
- * @param {Object} job Vector tile preparation job.
- * @param {Object} layer Decoded source layer.
- * @param {Object} entry Style layer entry.
- * @param {Object} properties Feature properties.
- * @param {number} order Style layer order.
- * @param {string} text Label text.
- * @param {Object} icon Sprite icon.
- * @param {Object} anchor Label anchor and optional line endpoints.
- * @param {number} size Text size.
- *
- * @returns {Object} Label candidate.
- */
-export function createVectorLabel(job, layer, entry, properties, order, text, icon, anchor, size) {
-  return /* alloc */ {
-    text, latlng: projectVectorPoint(anchor.point, job.coords, layer.extent),
-    order, entry, properties, size, pixelBase: anchor.length * 256 / layer.extent / 2 ** job.coords.z,
-    along: anchor.a ? /* alloc */ [
-      projectVectorPoint(anchor.a, job.coords, layer.extent),
-      projectVectorPoint(anchor.b, job.coords, layer.extent),
-    ] : null,
-    icon: text.trim() ? null : icon,
-    iconOffset: evaluateStyle(entry.layout?.['icon-offset'], properties, job.zoom) || /* alloc */ [0, 0],
-    allowOverlap: entry.layout?.['icon-allow-overlap'] === true,
-    color: vectorStyleValue(entry.paint, 'text-color', '#000', properties, job.zoom),
-    halo: vectorStyleValue(entry.paint, 'text-halo-color', '#fff', properties, job.zoom),
-    haloWidth: vectorStyleValue(entry.paint, 'text-halo-width', 0, properties, job.zoom),
-    priority: /* alloc */ ['place_labels', 'place'].includes(entry['source-layer']) ? 0
-      : /* alloc */ ['street_labels', 'transportation_name'].includes(entry['source-layer']) ? 1 : 2,
-  };
-}
+import { evaluateStyle } from '../vector-style/evaluateStyle.js';
+import { projectVectorPoint } from './projectVectorPoint.js';
+import { vectorStyleValue } from './vectorStyleValue.js';
+
+/**
+ * Construct a projected vector label candidate with evaluated style properties.
+ *
+ * @param {Object} job Vector tile preparation job.
+ * @param {Object} layer Decoded source layer.
+ * @param {Object} entry Style layer entry.
+ * @param {Object} properties Feature properties.
+ * @param {number} order Style layer order.
+ * @param {string} text Label text.
+ * @param {Object} icon Sprite icon.
+ * @param {Object} anchor Label anchor and optional line endpoints.
+ * @param {number} size Text size.
+ *
+ * @returns {Object} Label candidate.
+ */
+export function createVectorLabel(job, layer, entry, properties, order, text, icon, anchor, size) {
+  return /* alloc */ {
+    text, latlng: projectVectorPoint(anchor.point, job.coords, layer.extent),
+    order, entry, properties, size, pixelBase: anchor.length * 256 / layer.extent / 2 ** job.coords.z,
+    along: anchor.a ? /* alloc */ [
+      projectVectorPoint(anchor.a, job.coords, layer.extent),
+      projectVectorPoint(anchor.b, job.coords, layer.extent),
+    ] : null,
+    icon: text.trim() ? null : icon,
+    iconOffset: evaluateStyle(entry.layout?.['icon-offset'], properties, job.zoom) || /* alloc */ [0, 0],
+    allowOverlap: entry.layout?.['icon-allow-overlap'] === true,
+    color: vectorStyleValue(entry.paint, 'text-color', '#000', properties, job.zoom),
+    halo: vectorStyleValue(entry.paint, 'text-halo-color', '#fff', properties, job.zoom),
+    haloWidth: vectorStyleValue(entry.paint, 'text-halo-width', 0, properties, job.zoom),
+    priority: /* alloc */ ['place_labels', 'place'].includes(entry['source-layer']) ? 0
+      : /* alloc */ ['street_labels', 'transportation_name'].includes(entry['source-layer']) ? 1 : 2,
+  };
+}

package/src/vector-tiles/forwardVectorTileError.js

@@ -1,10 +1,10 @@
-import { reportError } from '../scene/reportLayerError.js';
-
-/**
- * Report a rendered vector batch error on its owning layer.
- *
- * @param {Object} event Error event.
- */
-export function forwardVectorTileError({ error }) {
-  reportError(this, error);
-}
+import { reportError } from '../scene/reportLayerError.js';
+
+/**
+ * Report a rendered vector batch error on its owning layer.
+ *
+ * @param {Object} event Error event.
+ */
+export function forwardVectorTileError({ error }) {
+  reportError(this, error);
+}

package/src/vector-tiles/loadVectorSprite.js

@@ -1,14 +1,14 @@
-/**
- * Load the sprite index and derive the corresponding image URL.
- *
- * @param {string} url Sprite URL without extension.
- *
- * @returns {Promise<Object>} Sprite image URL and index.
- *
- * @throws {Error} If the sprite index request returns an unsuccessful status.
- */
-export async function loadVectorSprite(url) {
-  const response = await fetch(`${url}.json`);
-  if (!response.ok) throw /* alloc */ new Error(`Sprite ${url}.json: HTTP ${response.status}`);
-  return /* alloc */ { url: `${url}.png`, index: await response.json() };
-}
+/**
+ * Load the sprite index and derive the corresponding image URL.
+ *
+ * @param {string} url Sprite URL without extension.
+ *
+ * @returns {Promise<Object>} Sprite image URL and index.
+ *
+ * @throws {Error} If the sprite index request returns an unsuccessful status.
+ */
+export async function loadVectorSprite(url) {
+  const response = await fetch(`${url}.json`);
+  if (!response.ok) throw /* alloc */ new Error(`Sprite ${url}.json: HTTP ${response.status}`);
+  return /* alloc */ { url: `${url}.png`, index: await response.json() };
+}

package/src/vector-tiles/loadVectorTile.js

@@ -1,45 +1,45 @@
-import { L } from '../globals/L.js';
-import { vectorTileOptionsByLayer } from '../weakmaps/vectorTileOptionsByLayer.js';
-import { vectorStyleZoom } from './vectorStyleZoom.js';
-import { attachVectorTileBatches } from './attachVectorTileBatches.js';
-
-/**
- * Fetch, prepare and attach a vector tile while its session remains current.
- *
- * @param {Object} tile Tile state and abort controller.
- *
- * @returns {Promise<void>} Completion of the load or error reporting.
- *
- * @throws {Error} HTTP errors are caught internally and emitted on the owning layer.
- */
-export async function loadVectorTile(tile) {
-  const { coords, controller } = tile, session = this.session;
-  const { url, style, sourceId, maxZoom, maxNativeZoom } = vectorTileOptionsByLayer.get(this);
-  const count = 2 ** coords.z, x = ((coords.x % count) + count) % count;
-  let group;
-  try {
-    const tileUrl = L.Util.template(url, /* alloc */ { z: coords.z, x, y: coords.y });
-    const response = await fetch(tileUrl, /* alloc */ { signal: controller.signal });
-    if (!response.ok) throw /* alloc */ new Error(`Tile ${tile.key}: HTTP ${response.status}`);
-    const buffer = await response.arrayBuffer();
-    if (controller.signal.aborted) return;
-    const id = ++this.sequence, prepared = Promise.withResolvers();
-    this.waiting.set(id, prepared);
-    this.worker.postMessage(/* alloc */ { type: 'vector', id, buffer, coords, style, source: sourceId, maxZoom,
-      zoom: vectorStyleZoom(this), mapZoom: coords.z >= maxNativeZoom ? maxZoom : this._map.getZoom() }, /* alloc */ [buffer]);
-    const data = await prepared.promise;
-    if (controller.signal.aborted || this.session !== session) return;
-    group = /* alloc */ new L.LayerGroup().addTo(this._map);
-    tile.rendered = /* alloc */ [];
-    if (!await attachVectorTileBatches(this, tile, group, data.batches, session)) { group.remove(); return; }
-    tile.group = group; tile.labelCandidates = data.labels;
-    this.fire('tileload', /* alloc */ { coords, group });
-    this.prune();
-    this.refresh();
-  } catch (error) {
-    group?.remove();
-    if (!controller.signal.aborted && this.session === session) this.fire('error', /* alloc */ { error });
-  } finally {
-    if (this.session === session) { this.inflight--; this.pump(); }
-  }
-}
+import { L } from '../globals/L.js';
+import { vectorTileOptionsByLayer } from '../weakmaps/vectorTileOptionsByLayer.js';
+import { vectorStyleZoom } from './vectorStyleZoom.js';
+import { attachVectorTileBatches } from './attachVectorTileBatches.js';
+
+/**
+ * Fetch, prepare and attach a vector tile while its session remains current.
+ *
+ * @param {Object} tile Tile state and abort controller.
+ *
+ * @returns {Promise<void>} Completion of the load or error reporting.
+ *
+ * @throws {Error} HTTP errors are caught internally and emitted on the owning layer.
+ */
+export async function loadVectorTile(tile) {
+  const { coords, controller } = tile, session = this.session;
+  const { url, style, sourceId, maxZoom, maxNativeZoom } = vectorTileOptionsByLayer.get(this);
+  const count = 2 ** coords.z, x = ((coords.x % count) + count) % count;
+  let group;
+  try {
+    const tileUrl = L.Util.template(url, /* alloc */ { z: coords.z, x, y: coords.y });
+    const response = await fetch(tileUrl, /* alloc */ { signal: controller.signal });
+    if (!response.ok) throw /* alloc */ new Error(`Tile ${tile.key}: HTTP ${response.status}`);
+    const buffer = await response.arrayBuffer();
+    if (controller.signal.aborted) return;
+    const id = ++this.sequence, prepared = Promise.withResolvers();
+    this.waiting.set(id, prepared);
+    this.worker.postMessage(/* alloc */ { type: 'vector', id, buffer, coords, style, source: sourceId, maxZoom,
+      zoom: vectorStyleZoom(this), mapZoom: coords.z >= maxNativeZoom ? maxZoom : this._map.getZoom() }, /* alloc */ [buffer]);
+    const data = await prepared.promise;
+    if (controller.signal.aborted || this.session !== session) return;
+    group = /* alloc */ new L.LayerGroup().addTo(this._map);
+    tile.rendered = /* alloc */ [];
+    if (!await attachVectorTileBatches(this, tile, group, data.batches, session)) { group.remove(); return; }
+    tile.group = group; tile.labelCandidates = data.labels;
+    this.fire('tileload', /* alloc */ { coords, group });
+    this.prune();
+    this.refresh();
+  } catch (error) {
+    group?.remove();
+    if (!controller.signal.aborted && this.session === session) this.fire('error', /* alloc */ { error });
+  } finally {
+    if (this.session === session) { this.inflight--; this.pump(); }
+  }
+}

package/src/vector-tiles/onVectorTileAdd.js

@@ -1,44 +1,44 @@
-import { vectorTileOptionsByLayer } from '../weakmaps/vectorTileOptionsByLayer.js';
-import { geometryWorkerUrl } from '../globals/geometryWorkerUrl.js';
-import { vectorTileEvents } from '../globals/vectorTileEvents.js';
-import { evaluateStyle } from '../vector-style/evaluateStyle.js';
-import { vectorStyleZoom } from './vectorStyleZoom.js';
-import { refreshVectorTiles } from './refreshVectorTiles.js';
-import { rotateVectorLabels } from './rotateVectorLabels.js';
-import { onVectorTileMessage } from './onVectorTileMessage.js';
-import { onVectorTileWorkerError } from './onVectorTileWorkerError.js';
-import { createGeometryWorker } from '../workers/createGeometryWorker.js';
-import { vectorWorkerByLayer } from '../weakmaps/vectorWorkerByLayer.js';
-
-/**
- * Initialize vector tile panes, worker and map listeners when the layer is added.
- *
- * @param {Object} map Leaflet map.
- */
-export function onVectorTileAdd(map) {
-  const { style, pane } = vectorTileOptionsByLayer.get(this);
-  let index, entry;
-  for ([index] of style.entries()) {
-    (map.getPane(`${pane}-${index}`) || map.createPane(`${pane}-${index}`)).style.zIndex = 200 + index;
-  }
-  for (entry of style) {
-    if (entry.type !== 'background') continue;
-    map.getContainer().style.background = evaluateStyle(entry.paint['background-color'], /* alloc */ {}, vectorStyleZoom(this));
-    break;
-  }
-  this.session = /* alloc */ {};
-  this.tiles = /* alloc */ new Map(); this.labels = /* alloc */ new Map(); this.waiting = /* alloc */ new Map();
-  this.retiring = /* alloc */ new Set();
-  this.inflight = 0; this.sequence = 0;
-  this.changedAt = 0; this.paintZoom = null;
-  const workerEntry = createGeometryWorker(this.options.workerUrl || geometryWorkerUrl);
-  vectorWorkerByLayer.set(this, workerEntry);
-  this.worker = workerEntry.worker;
-  this.worker.onmessage = onVectorTileMessage.bind(this);
-  this.worker.onerror = onVectorTileWorkerError.bind(this);
-  this.refresh = refreshVectorTiles.bind(this);
-  this.rotateLabels = rotateVectorLabels.bind(this);
-  map.on(vectorTileEvents, this.refresh);
-  map.on('move rotate pitch', this.rotateLabels);
-  this.update();
-}
+import { vectorTileOptionsByLayer } from '../weakmaps/vectorTileOptionsByLayer.js';
+import { geometryWorkerUrl } from '../globals/geometryWorkerUrl.js';
+import { vectorTileEvents } from '../globals/vectorTileEvents.js';
+import { evaluateStyle } from '../vector-style/evaluateStyle.js';
+import { vectorStyleZoom } from './vectorStyleZoom.js';
+import { refreshVectorTiles } from './refreshVectorTiles.js';
+import { rotateVectorLabels } from './rotateVectorLabels.js';
+import { onVectorTileMessage } from './onVectorTileMessage.js';
+import { onVectorTileWorkerError } from './onVectorTileWorkerError.js';
+import { createGeometryWorker } from '../workers/createGeometryWorker.js';
+import { vectorWorkerByLayer } from '../weakmaps/vectorWorkerByLayer.js';
+
+/**
+ * Initialize vector tile panes, worker and map listeners when the layer is added.
+ *
+ * @param {Object} map Leaflet map.
+ */
+export function onVectorTileAdd(map) {
+  const { style, pane } = vectorTileOptionsByLayer.get(this);
+  let index, entry;
+  for ([index] of style.entries()) {
+    (map.getPane(`${pane}-${index}`) || map.createPane(`${pane}-${index}`)).style.zIndex = 200 + index;
+  }
+  for (entry of style) {
+    if (entry.type !== 'background') continue;
+    map.getContainer().style.background = evaluateStyle(entry.paint['background-color'], /* alloc */ {}, vectorStyleZoom(this));
+    break;
+  }
+  this.session = /* alloc */ {};
+  this.tiles = /* alloc */ new Map(); this.labels = /* alloc */ new Map(); this.waiting = /* alloc */ new Map();
+  this.retiring = /* alloc */ new Set();
+  this.inflight = 0; this.sequence = 0;
+  this.changedAt = 0; this.paintZoom = null;
+  const workerEntry = createGeometryWorker(this.options.workerUrl || geometryWorkerUrl);
+  vectorWorkerByLayer.set(this, workerEntry);
+  this.worker = workerEntry.worker;
+  this.worker.onmessage = onVectorTileMessage.bind(this);
+  this.worker.onerror = onVectorTileWorkerError.bind(this);
+  this.refresh = refreshVectorTiles.bind(this);
+  this.rotateLabels = rotateVectorLabels.bind(this);
+  map.on(vectorTileEvents, this.refresh);
+  map.on('move rotate pitch', this.rotateLabels);
+  this.update();
+}

package/src/vector-tiles/onVectorTileMessage.js

@@ -1,15 +1,15 @@
-import { revokeVectorWorkerUrl } from './revokeVectorWorkerUrl.js';
-
-/**
- * Resolve or reject the pending vector tile job for a worker response.
- *
- * @param {MessageEvent} event Worker message.
- */
-export function onVectorTileMessage({ data }) {
-  revokeVectorWorkerUrl(this);
-  const pending = this.waiting.get(data.id);
-  if (!pending) return;
-  this.waiting.delete(data.id);
-  if (data.error) pending.reject(/* alloc */ new Error(data.error));
-  else pending.resolve(data);
-}
+import { revokeVectorWorkerUrl } from './revokeVectorWorkerUrl.js';
+
+/**
+ * Resolve or reject the pending vector tile job for a worker response.
+ *
+ * @param {MessageEvent} event Worker message.
+ */
+export function onVectorTileMessage({ data }) {
+  revokeVectorWorkerUrl(this);
+  const pending = this.waiting.get(data.id);
+  if (!pending) return;
+  this.waiting.delete(data.id);
+  if (data.error) pending.reject(/* alloc */ new Error(data.error));
+  else pending.resolve(data);
+}

package/src/vector-tiles/onVectorTileRemove.js

@@ -1,25 +1,25 @@
-import { vectorTileEvents } from '../globals/vectorTileEvents.js';
-import { vectorWorkerByLayer } from '../weakmaps/vectorWorkerByLayer.js';
-import { revokeVectorWorkerUrl } from './revokeVectorWorkerUrl.js';
-
-/**
- * Remove listeners, cancel pending work and dispose rendered vector tiles and labels.
- *
- * @param {Object} map Leaflet map.
- */
-export function onVectorTileRemove(map) {
-  map.off(vectorTileEvents, this.refresh);
-  map.off('move rotate pitch', this.rotateLabels);
-  clearTimeout(this.timer);
-  this.session = null;
-  this.worker.terminate();
-  revokeVectorWorkerUrl(this);
-  vectorWorkerByLayer.delete(this);
-  let pending, tile, group, marker;
-  for (pending of this.waiting.values()) pending.reject(/* alloc */ new DOMException('Layer removed', 'AbortError'));
-  this.waiting.clear();
-  for (tile of this.tiles.values()) { tile.controller.abort(); tile.group?.remove(); }
-  for (group of this.retiring) group.remove();
-  for (marker of this.labels.values()) marker.remove();
-  this.tiles.clear(); this.labels.clear(); this.retiring.clear();
-}
+import { vectorTileEvents } from '../globals/vectorTileEvents.js';
+import { vectorWorkerByLayer } from '../weakmaps/vectorWorkerByLayer.js';
+import { revokeVectorWorkerUrl } from './revokeVectorWorkerUrl.js';
+
+/**
+ * Remove listeners, cancel pending work and dispose rendered vector tiles and labels.
+ *
+ * @param {Object} map Leaflet map.
+ */
+export function onVectorTileRemove(map) {
+  map.off(vectorTileEvents, this.refresh);
+  map.off('move rotate pitch', this.rotateLabels);
+  clearTimeout(this.timer);
+  this.session = null;
+  this.worker.terminate();
+  revokeVectorWorkerUrl(this);
+  vectorWorkerByLayer.delete(this);
+  let pending, tile, group, marker;
+  for (pending of this.waiting.values()) pending.reject(/* alloc */ new DOMException('Layer removed', 'AbortError'));
+  this.waiting.clear();
+  for (tile of this.tiles.values()) { tile.controller.abort(); tile.group?.remove(); }
+  for (group of this.retiring) group.remove();
+  for (marker of this.labels.values()) marker.remove();
+  this.tiles.clear(); this.labels.clear(); this.retiring.clear();
+}

package/src/vector-tiles/onVectorTileWorkerError.js

@@ -1,16 +1,16 @@
-import { reportError } from '../scene/reportLayerError.js';
-import { revokeVectorWorkerUrl } from './revokeVectorWorkerUrl.js';
-
-/**
- * Reject pending vector jobs and report a worker error to the layer.
- *
- * @param {ErrorEvent} event Worker error event.
- */
-export function onVectorTileWorkerError(event) {
-  revokeVectorWorkerUrl(this);
-  const error = /* alloc */ new Error(`Worker MVT: ${event.message}`);
-  let pending;
-  for (pending of this.waiting.values()) pending.reject(error);
-  this.waiting.clear();
-  reportError(this, error);
-}
+import { reportError } from '../scene/reportLayerError.js';
+import { revokeVectorWorkerUrl } from './revokeVectorWorkerUrl.js';
+
+/**
+ * Reject pending vector jobs and report a worker error to the layer.
+ *
+ * @param {ErrorEvent} event Worker error event.
+ */
+export function onVectorTileWorkerError(event) {
+  revokeVectorWorkerUrl(this);
+  const error = /* alloc */ new Error(`Worker MVT: ${event.message}`);
+  let pending;
+  for (pending of this.waiting.values()) pending.reject(error);
+  this.waiting.clear();
+  reportError(this, error);
+}

package/src/vector-tiles/paintVectorTileBatch.js

@@ -1,18 +1,18 @@
-import { vectorTilePaint } from './vectorTilePaint.js';
-
-/**
- * Update a rendered vector batch's paint at the given zoom.
- *
- * @param {Object} batch Rendered batch and its style entry.
- * @param {number} zoom Style zoom.
- */
-export function paintVectorTileBatch(batch, zoom) {
-  const paint = vectorTilePaint(batch, zoom), { layer } = batch;
-  if (batch.kind === 'line') {
-    if (paint.dashArray !== layer.options.dashArray) layer.setStyle(paint);
-    else layer.setStyle(/* alloc */ { color: paint.color, opacity: paint.opacity, weight: paint.weight });
-  } else if (JSON.stringify(paint.fillColor) !== JSON.stringify(layer.options.fillColor) ||
-      paint.fillOpacity !== layer.options.fillOpacity) {
-    layer.setStyle(/* alloc */ { fillColor: paint.fillColor, fillOpacity: paint.fillOpacity });
-  }
-}
+import { vectorTilePaint } from './vectorTilePaint.js';
+
+/**
+ * Update a rendered vector batch's paint at the given zoom.
+ *
+ * @param {Object} batch Rendered batch and its style entry.
+ * @param {number} zoom Style zoom.
+ */
+export function paintVectorTileBatch(batch, zoom) {
+  const paint = vectorTilePaint(batch, zoom), { layer } = batch;
+  if (batch.kind === 'line') {
+    if (paint.dashArray !== layer.options.dashArray) layer.setStyle(paint);
+    else layer.setStyle(/* alloc */ { color: paint.color, opacity: paint.opacity, weight: paint.weight });
+  } else if (JSON.stringify(paint.fillColor) !== JSON.stringify(layer.options.fillColor) ||
+      paint.fillOpacity !== layer.options.fillOpacity) {
+    layer.setStyle(/* alloc */ { fillColor: paint.fillColor, fillOpacity: paint.fillOpacity });
+  }
+}

package/src/vector-tiles/prepareVectorLabel.js

@@ -1,34 +1,34 @@
-import { evaluateStyle } from '../vector-style/evaluateStyle.js';
-import { vectorStyleValue } from './vectorStyleValue.js';
-import { vectorLabelAnchors } from './vectorLabelAnchors.js';
-import { vectorLabelText } from './vectorLabelText.js';
-import { createVectorLabel } from './createVectorLabel.js';
-
-/**
- * Add in-tile label candidates for a styled vector feature.
- *
- * @param {Object} job Vector tile preparation job.
- * @param {Object} layer Decoded source layer.
- * @param {Object} entry Style layer entry.
- * @param {Object} feature Decoded feature.
- * @param {number} order Style layer order.
- */
-export function prepareVectorLabel(job, layer, entry, feature, order) {
-  const { properties } = feature, { zoom } = job;
-  const text = vectorLabelText(entry, properties, zoom);
-  const icon = entry.layout?.['symbol-placement'] === 'line' ? null
-    : evaluateStyle(entry.layout?.['icon-image'], properties, zoom);
-  if (!text.trim() && typeof icon !== 'string') return;
-  const size = vectorStyleValue(entry.layout, 'text-size', 12, properties, zoom), line = feature.type === 2 && text.trim();
-  const spacing = layer.extent / 16, anchors = /* alloc */ [];
-  let path, anchor;
-  for (path of line ? feature.geometry : feature.geometry.slice(0, 1)) {
-    if (!path?.length) continue;
-    if (!line) anchors.push(/* alloc */ { point: path[Math.floor(path.length / 2)], a: null });
-    else for (anchor of vectorLabelAnchors(path, spacing)) anchors.push(anchor);
-  }
-  for (anchor of anchors) {
-    if (anchor.point[0] < 0 || anchor.point[0] >= layer.extent || anchor.point[1] < 0 || anchor.point[1] >= layer.extent) continue;
-    job.labels.push(createVectorLabel(job, layer, entry, properties, order, text, icon, anchor, size));
-  }
-}
+import { evaluateStyle } from '../vector-style/evaluateStyle.js';
+import { vectorStyleValue } from './vectorStyleValue.js';
+import { vectorLabelAnchors } from './vectorLabelAnchors.js';
+import { vectorLabelText } from './vectorLabelText.js';
+import { createVectorLabel } from './createVectorLabel.js';
+
+/**
+ * Add in-tile label candidates for a styled vector feature.
+ *
+ * @param {Object} job Vector tile preparation job.
+ * @param {Object} layer Decoded source layer.
+ * @param {Object} entry Style layer entry.
+ * @param {Object} feature Decoded feature.
+ * @param {number} order Style layer order.
+ */
+export function prepareVectorLabel(job, layer, entry, feature, order) {
+  const { properties } = feature, { zoom } = job;
+  const text = vectorLabelText(entry, properties, zoom);
+  const icon = entry.layout?.['symbol-placement'] === 'line' ? null
+    : evaluateStyle(entry.layout?.['icon-image'], properties, zoom);
+  if (!text.trim() && typeof icon !== 'string') return;
+  const size = vectorStyleValue(entry.layout, 'text-size', 12, properties, zoom), line = feature.type === 2 && text.trim();
+  const spacing = layer.extent / 16, anchors = /* alloc */ [];
+  let path, anchor;
+  for (path of line ? feature.geometry : feature.geometry.slice(0, 1)) {
+    if (!path?.length) continue;
+    if (!line) anchors.push(/* alloc */ { point: path[Math.floor(path.length / 2)], a: null });
+    else for (anchor of vectorLabelAnchors(path, spacing)) anchors.push(anchor);
+  }
+  for (anchor of anchors) {
+    if (anchor.point[0] < 0 || anchor.point[0] >= layer.extent || anchor.point[1] < 0 || anchor.point[1] >= layer.extent) continue;
+    job.labels.push(createVectorLabel(job, layer, entry, properties, order, text, icon, anchor, size));
+  }
+}

package/src/vector-tiles/prepareVectorStyleLayer.js

@@ -1,38 +1,38 @@
-import { vectorStyleDependencies } from './vectorStyleDependencies.js';
-import { vectorFeatureZoom } from './vectorFeatureZoom.js';
-import { prepareVectorLabel } from './prepareVectorLabel.js';
-import { vectorFeaturePaint } from './vectorFeaturePaint.js';
-import { vectorPaint } from '../vector-style/vectorPaint.js';
-import { appendVectorBatch } from './appendVectorBatch.js';
-
-/**
- * Prepare labels or painted geometry batches for a vector style layer.
- *
- * @param {Object} job Vector tile preparation job.
- * @param {Object} layer Decoded source layer.
- * @param {Object} entry Style layer entry.
- * @param {number} order Style layer order.
- */
-export function prepareVectorStyleLayer(job, layer, entry, order) {
-  const batches = /* alloc */ new Map(), dependencies = vectorStyleDependencies(entry);
-  const outlineColor = entry.type === 'fill' ? entry.paint?.['fill-outline-color'] : null;
-  const outline = outlineColor ? /* alloc */ { ...entry, type: 'line',
-    paint: /* alloc */ { 'line-color': outlineColor, 'line-width': 1 } } : null;
-  let feature, sampleZoom, paint, batch;
-  for (feature of layer.features) {
-    sampleZoom = vectorFeatureZoom(entry, feature.properties, job.zoom, job.maxZoom);
-    if (sampleZoom < 0) continue;
-    if (entry.type === 'symbol') {
-      prepareVectorLabel(job, layer, entry, feature, order);
-      continue;
-    }
-    paint = vectorFeaturePaint(entry, feature, sampleZoom, job.maxZoom);
-    if (!paint) continue;
-    appendVectorBatch(job, layer, entry, feature, order, batches, dependencies, paint);
-    if (outline && feature.type === 3) {
-      appendVectorBatch(job, layer, outline, feature, order, batches, dependencies,
-        vectorPaint(outline, feature.properties, sampleZoom));
-    }
-  }
-  for (batch of batches.values()) if (batch.paths.length) job.output.push(batch);
-}
+import { vectorStyleDependencies } from './vectorStyleDependencies.js';
+import { vectorFeatureZoom } from './vectorFeatureZoom.js';
+import { prepareVectorLabel } from './prepareVectorLabel.js';
+import { vectorFeaturePaint } from './vectorFeaturePaint.js';
+import { vectorPaint } from '../vector-style/vectorPaint.js';
+import { appendVectorBatch } from './appendVectorBatch.js';
+
+/**
+ * Prepare labels or painted geometry batches for a vector style layer.
+ *
+ * @param {Object} job Vector tile preparation job.
+ * @param {Object} layer Decoded source layer.
+ * @param {Object} entry Style layer entry.
+ * @param {number} order Style layer order.
+ */
+export function prepareVectorStyleLayer(job, layer, entry, order) {
+  const batches = /* alloc */ new Map(), dependencies = vectorStyleDependencies(entry);
+  const outlineColor = entry.type === 'fill' ? entry.paint?.['fill-outline-color'] : null;
+  const outline = outlineColor ? /* alloc */ { ...entry, type: 'line',
+    paint: /* alloc */ { 'line-color': outlineColor, 'line-width': 1 } } : null;
+  let feature, sampleZoom, paint, batch;
+  for (feature of layer.features) {
+    sampleZoom = vectorFeatureZoom(entry, feature.properties, job.zoom, job.maxZoom);
+    if (sampleZoom < 0) continue;
+    if (entry.type === 'symbol') {
+      prepareVectorLabel(job, layer, entry, feature, order);
+      continue;
+    }
+    paint = vectorFeaturePaint(entry, feature, sampleZoom, job.maxZoom);
+    if (!paint) continue;
+    appendVectorBatch(job, layer, entry, feature, order, batches, dependencies, paint);
+    if (outline && feature.type === 3) {
+      appendVectorBatch(job, layer, outline, feature, order, batches, dependencies,
+        vectorPaint(outline, feature.properties, sampleZoom));
+    }
+  }
+  for (batch of batches.values()) if (batch.paths.length) job.output.push(batch);
+}