@map-zero/ol 0.3.2 → 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Marcos Pérez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@map-zero/ol",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "type": "module",
   "description": "OpenLayers integration helper for map-zero packages.",
   "license": "MIT",
@@ -22,7 +22,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@map-zero/raster": "0.3.2"
+    "@map-zero/core": "0.4.0"
   },
   "peerDependencies": {
     "ol": "10.10.0",

package/src/index.js

@@ -1,15 +1,12 @@
+import { LruCache, cachedPromise } from '../../core/src/shared/cache.js';
 import MVT from 'ol/format/MVT.js';
-import TileLayer from 'ol/layer/Tile.js';
 import WebGLVectorTileLayer from 'ol/layer/WebGLVectorTile.js';
 import WebGLVectorTileLayerRenderer from 'ol/renderer/webgl/VectorTileLayer.js';
-import ImageTileSource from 'ol/source/ImageTile.js';
 import VectorTileSource from 'ol/source/VectorTile.js';
 import { createXYZ } from 'ol/tilegrid.js';
 import { PMTiles } from 'pmtiles';
 
-import { isAipLayer, layerAlias } from '../../raster/src/shared/layers.js';
-import { pmtilesInfo } from '../../raster/src/shared/manifest.js';
-import { clampInteger, clampNumber } from '../../raster/src/shared/math.js';
+import { isAipLayer, layerAlias } from '../../core/src/shared/layers.js';
 import { maxZoomExpression, minZoomExpression, zoomInterpolateExpression } from './zoom.js';
 
 import {
@@ -57,12 +54,7 @@ const ROAD_HIGHWAY_DRAW_ORDER = [
  *   style?: string | Record<string, unknown>,
  *   visibleLayers?: string[] | Set<string>,
  *   source?: 'auto' | 'pmtiles' | 'dynamic',
- *   renderMode?: 'vector' | 'raster-worker',
  *   hitDetection?: boolean,
- *   workerUrl?: string | URL,
- *   rasterPixelRatio?: number,
- *   overzoomLevels?: number,
- *   edgeGuardPixels?: number,
  *   apiBaseUrl?: string,
  *   zIndexBase?: number,
  *   onTileLoadStart?: () => void,
@@ -135,9 +127,6 @@ export async function createMapZeroOpenLayersLayers(options) {
     onTileLoadError: options.onTileLoadError
   };
 
-  if (options.renderMode === 'raster-worker') {
-    return createRasterWorkerController(context, options);
-  }
 
   patchWebGlVectorTileRenderer();
 
@@ -233,193 +222,6 @@ export async function createMapZeroOpenLayersLayers(options) {
  *   destroy: () => void
  * }}
  */
-function createRasterWorkerController(context, options) {
-  if (!isPmtilesManifest(context.manifest)) {
-    throw new Error('raster-worker render mode requires vector PMTiles');
-  }
-
-  const worker = new MapZeroRasterTileWorker({
-    manifest: context.manifest,
-    manifestUrl: context.manifestUrl,
-    styleDocument: context.styleDocument,
-    layers: context.orderedLayers.map((layer) => layer.id),
-    workerUrl: options.workerUrl ?? new URL('@map-zero/raster/imagery-worker.js', import.meta.url),
-    rasterPixelRatio: options.rasterPixelRatio,
-    overzoomLevels: options.overzoomLevels,
-    edgeGuardPixels: options.edgeGuardPixels
-  });
-  worker.setVisibleLayers(context.layerVisibility);
-  const range = pmtilesZoomRange(context.manifest);
-  const maxZoom = range.maxZoom + clampInteger(options.overzoomLevels ?? 0, 0, 4);
-  const rasterPixelRatio = clampNumber(options.rasterPixelRatio ?? 2, 1, 2);
-  const source = new ImageTileSource({
-    minZoom: range.minZoom,
-    maxZoom,
-    tileGrid: createXYZ({
-      minZoom: range.minZoom,
-      maxZoom,
-      tileSize: 512
-    }),
-    tileSize: 512,
-    transition: 0,
-    interpolate: true,
-    zDirection: preferNearestZoomLevel,
-    wrapX: false,
-    loader: (z, x, y) => worker.render(z, x, y)
-  });
-  source.getTilePixelRatio = () => rasterPixelRatio;
-  const layer = new TileLayer({
-    source,
-    cacheSize: 4096,
-    preload: 0,
-    useInterimTilesOnError: false
-  });
-  tagOpenLayersLayer(layer, context.instanceId, context.orderedLayers.map((item) => item.id), 'raster');
-  applyLayerZIndex(layer, context.orderedLayers, context.styleDocument, options.zIndexBase);
-
-  const refresh = () => {
-    worker.setVisibleLayers(context.layerVisibility);
-    refreshRasterSource(source);
-    layer.changed();
-  };
-
-  return {
-    id: context.instanceId,
-    manifest: context.manifest,
-    style: context.styleDocument,
-    layers: [layer],
-    setVisible(layerId, visible) {
-      if (!context.layerVisibility.has(layerId)) {
-        throw new Error(`unknown map-zero layer: ${layerId}`);
-      }
-
-      context.layerVisibility.set(layerId, Boolean(visible));
-      refresh();
-    },
-    setOpacity(layerId, opacity) {
-      if (!context.layerOpacity?.has?.(layerId)) {
-        throw new Error(`unknown map-zero layer: ${layerId}`);
-      }
-
-      layer.setOpacity(clamp(Number(opacity), 0, 1));
-    },
-    destroy() {
-      refreshRasterSource(source);
-      worker.destroy();
-      layer.dispose();
-    }
-  };
-}
-
-function refreshRasterSource(source) {
-  source.clear();
-  source.refresh?.();
-}
-
-class MapZeroRasterTileWorker {
-  /**
-   * @param {{
-   *   manifest: Record<string, unknown>,
-   *   manifestUrl: string,
-   *   styleDocument: Record<string, unknown>,
-   *   layers: string[],
-   *   workerUrl: string | URL,
-   *   rasterPixelRatio?: number,
-   *   overzoomLevels?: number,
-   *   edgeGuardPixels?: number
-   * }} options
-   */
-  constructor(options) {
-    assertRasterWorkerSupport();
-    this.#rasterPixelRatio = clampNumber(options.rasterPixelRatio ?? 2, 1, 2);
-    this.worker = new Worker(options.workerUrl, { type: 'module' });
-    this.worker.addEventListener('message', (event) => this.#handleMessage(event.data));
-    this.worker.addEventListener('error', (event) => this.#rejectAll(new Error(event.message || 'map-zero OpenLayers raster worker failed')));
-    this.worker.postMessage({
-      type: 'init',
-      options: {
-        manifest: options.manifest,
-        manifestUrl: resolveUrl(options.manifestUrl, documentBaseUrl()),
-        styleDocument: options.styleDocument,
-        layers: options.layers,
-        tileSize: 512,
-        pixelRatio: this.#rasterPixelRatio,
-        sourceMaximumLevel: pmtilesZoomRange(options.manifest).maxZoom,
-        overzoomLevels: clampInteger(options.overzoomLevels ?? 0, 0, 4),
-        edgeGuardPixels: clampInteger(options.edgeGuardPixels ?? 0, 0, 8),
-        source: String(pmtilesInfo(options.manifest).url ?? 'tiles.pmtiles')
-      }
-    });
-  }
-
-  /**
-   * @param {number} z
-   * @param {number} x
-   * @param {number} y
-   * @returns {Promise<ImageBitmap | HTMLCanvasElement>}
-   */
-  render(z, x, y) {
-    const id = this.#nextId++;
-    return new Promise((resolve, reject) => {
-      this.#pending.set(id, { resolve, reject });
-      this.worker.postMessage({ type: 'render', id, x, y, z });
-    }).catch(() => emptyCanvas(512 * this.#rasterPixelRatio, 512 * this.#rasterPixelRatio));
-  }
-
-  /**
-   * @param {Map<string, boolean>} visibility
-   */
-  setVisibleLayers(visibility) {
-    for (const [layerId, visible] of visibility) {
-      this.worker.postMessage({ type: 'visibility', layerId, visible });
-    }
-  }
-
-  destroy() {
-    this.#rejectAll(new Error('map-zero OpenLayers raster worker destroyed'));
-    this.worker.terminate();
-  }
-
-  /**
-   * @param {any} message
-   */
-  #handleMessage(message) {
-    if (message?.type !== 'tile') {
-      return;
-    }
-
-    const pending = this.#pending.get(message.id);
-    if (!pending) {
-      message.image?.close?.();
-      return;
-    }
-
-    this.#pending.delete(message.id);
-    if (message.error) {
-      pending.reject(new Error(message.error));
-      return;
-    }
-    pending.resolve(message.image ?? emptyCanvas(512, 512));
-  }
-
-  /**
-   * @param {Error} error
-   */
-  #rejectAll(error) {
-    for (const pending of this.#pending.values()) {
-      pending.reject(error);
-    }
-    this.#pending.clear();
-  }
-
-  /** @type {Worker} */
-  worker;
-  #rasterPixelRatio = 2;
-  #nextId = 1;
-  /** @type {Map<number, { resolve: (image: ImageBitmap | HTMLCanvasElement) => void, reject: (error: Error) => void }>} */
-  #pending = new Map();
-}
-
 /**
  * Add map-zero layers to an existing OpenLayers map.
  *
@@ -580,7 +382,7 @@ function applyLayerZIndex(layer, orderedLayers, styleDocument, zIndexBase) {
  * @param {unknown} layer
  * @param {string} instanceId
  * @param {string[]} layerIds
- * @param {'geometry' | 'labels' | 'raster'} role
+ * @param {'geometry' | 'labels'} role
  */
 function tagOpenLayersLayer(layer, instanceId, layerIds, role) {
   const namespacedLayerIds = layerIds.map((layerId) => namespaceLayerId(instanceId, layerId));
@@ -879,8 +681,14 @@ function createLabelTileDataLoader(context) {
  * @returns {PMTiles}
  */
 function createPmtilesArchive(context) {
+  if (context.archive) return context.archive;
   const tiles = /** @type {{ url: string }} */ (context.manifest.tiles);
-  return new PMTiles(resolveUrl(tiles.url, context.manifestBaseUrl));
+  const archive = new PMTiles(resolveUrl(tiles.url, context.manifestBaseUrl));
+  const cache = new LruCache(128);
+  const getZxy = archive.getZxy.bind(archive);
+  archive.getZxy = (z, x, y) => cachedPromise(cache, `${z}/${x}/${y}`, () => getZxy(z, x, y));
+  context.archive = archive;
+  return archive;
 }
 
 /**
@@ -2099,38 +1907,6 @@ function isValidTileCoord(z, x, y) {
   return Number.isInteger(x) && Number.isInteger(y) && x >= 0 && y >= 0 && x < maxIndex && y < maxIndex;
 }
 
-/**
- * @param {number} width
- * @param {number} height
- * @returns {HTMLCanvasElement}
- */
-function emptyCanvas(width, height) {
-  const canvas = document.createElement('canvas');
-  canvas.width = width;
-  canvas.height = height;
-  return canvas;
-}
-
-function assertRasterWorkerSupport() {
-  if (typeof Worker !== 'function' || typeof OffscreenCanvas !== 'function' || typeof createImageBitmap !== 'function') {
-    throw new Error('map-zero OpenLayers raster-worker mode requires Worker, OffscreenCanvas, and createImageBitmap');
-  }
-}
-
-/**
- * Choose the raster tile zoom at the midpoint in zoom space instead of always
- * forcing the parent or child tile. This keeps fractional zooms sharp without
- * holding low-resolution tiles for too long.
- *
- * @param {number} value
- * @param {number} high
- * @param {number} low
- * @returns {number}
- */
-function preferNearestZoomLevel(value, high, low) {
-  return value - low * Math.sqrt(high / low);
-}
-
 /**
  * @param {number} z
  * @param {number} x

package/src/labels.js

@@ -1,3 +1,4 @@
+import { LruCache } from '../../core/src/shared/cache.js';
 import Feature from 'ol/Feature.js';
 import MVT from 'ol/format/MVT.js';
 import VectorTileLayer from 'ol/layer/VectorTile.js';
@@ -7,153 +8,34 @@ import Stroke from 'ol/style/Stroke.js';
 import Style from 'ol/style/Style.js';
 import Text from 'ol/style/Text.js';
 
-const LABEL_SOURCE_LAYERS = ['roads', 'aip', 'aviation', 'pois'];
-const ROAD_SOURCE_LAYER = 'roads';
-const AIP_SOURCE_LAYERS = new Set(['aip', 'aviation']);
-const POI_SOURCE_LAYER = 'pois';
+import {
+  activeLabelLayerIdsForZoom,
+  hasEnabledLabels,
+  isPoiLikeFeature,
+  isSelectedPoiCandidate,
+  roadLabel,
+  aviationLabel,
+  isSelectedPoi,
+  poiLabelText,
+  priorityClassFromNumber,
+  poiPriorityClass,
+  poiZIndex,
+  labelFont,
+  priorityClassRule,
+  labelOpacityForZoom,
+  cleanText,
+  isMeaningfulLabel,
+  isExplicitAviationLabel,
+  labelRuleForSource,
+  zoomInRule,
+  resolutionToZoom,
+  rgba,
+  LABEL_SOURCE_LAYERS,
+  ROAD_SOURCE_LAYER,
+  POI_SOURCE_LAYER
+} from '../../core/src/labels.js';
+export { activeLabelLayerIdsForZoom, hasEnabledLabels } from '../../core/src/labels.js';
 
-const MAJOR_ROADS = new Set(['motorway', 'motorway_link', 'trunk', 'trunk_link', 'primary', 'primary_link']);
-const SECONDARY_ROADS = new Set(['secondary', 'secondary_link']);
-const LOCAL_ROADS = new Set(['residential', 'living_street', 'unclassified']);
-const DISABLED_ROADS = new Set(['service', 'track', 'path', 'footway', 'cycleway', 'steps', 'corridor', 'platform']);
-const LABEL_TEXT_FIELDS = ['name', 'ref', 'iata', 'icao', 'operator', 'official_name', 'short_name'];
-const GENERIC_LABEL_VALUES = new Set([
-  'yes',
-  'no',
-  'true',
-  'false',
-  'unknown',
-  'none',
-  'generator',
-  'tower',
-  'line',
-  'plant',
-  'substation',
-  'transformer',
-  'mast',
-  'antenna',
-  'station',
-  'airport',
-  'aerodrome',
-  'runway',
-  'taxiway',
-  'terminal',
-  'apron',
-  'pharmacy',
-  'fuel',
-  'charging_station',
-  'hospital',
-  'clinic',
-  'police',
-  'fire_station',
-  'fire_hydrant',
-  'defibrillator',
-  'fire_extinguisher',
-  'shelter',
-  'railway_station',
-  'train_station',
-  'subway_station',
-  'bus_station',
-  'ferry_terminal',
-  'townhall',
-  'courthouse',
-  'prison',
-  'bunker',
-  'checkpoint',
-  'communications_tower',
-  'protected_area',
-  'nature_reserve',
-  'restaurant',
-  'cafe',
-  'bar',
-  'fast_food',
-  'pub',
-  'shop',
-  'retail',
-  'commercial',
-  'tourism',
-  'attraction',
-  'hotel',
-  'transport',
-  'emergency',
-  'government',
-  'energy',
-  'communications',
-  'protected',
-  'industrial',
-  'military',
-  'operational',
-  'consumer'
-]);
-const DEFAULT_POI_CLASSES = {
-  amenity: [
-    'hospital',
-    'police',
-    'fire_station',
-    'bus_station',
-    'ferry_terminal',
-    'shelter',
-    'townhall',
-    'courthouse',
-    'prison',
-    'ranger_station',
-    'research_institute',
-    'airport',
-    'railway_station',
-    'train_station',
-    'subway_station',
-    'communications_tower',
-    'bunker',
-    'checkpoint',
-    'depot',
-    'warehouse'
-  ],
-  tourism: ['information'],
-  shop: [],
-  leisure: ['nature_reserve'],
-  railway: ['station'],
-  public_transport: ['station'],
-  station: ['subway'],
-  aeroway: ['aerodrome', 'airport'],
-  power: ['plant', 'substation', 'generator', 'tower', 'transformer', 'line'],
-  man_made: ['communications_tower', 'mast', 'antenna'],
-  'tower:type': ['communication'],
-  military: ['barracks', 'bunker', 'checkpoint', 'airbase', 'naval_base', 'range', 'training_area', 'base', 'airfield', 'danger_area', 'ammunition_dump'],
-  emergency: ['ambulance_station', 'siren', 'assembly_point', 'disaster_response'],
-  office: ['government'],
-  government: ['yes', 'public_safety', 'border_control', 'customs', 'ministry', 'aerospace'],
-  boundary: ['protected_area'],
-  industrial: ['refinery', 'depot', 'storage', 'logistics'],
-  landuse: ['industrial']
-};
-
-/**
- * Tiny full-label bitmap atlas kept for future point-label experiments.
- */
-export class LabelAtlas {
-  constructor() {
-    this.map = new Map();
-  }
-}
-
-/**
- * Create a standard OpenLayers vector tile label layer.
- *
- * Geometry rendering stays on the existing WebGLVectorTileLayer. This layer is
- * only for labels, using OpenLayers text placement and decluttering.
- *
- * @param {{
- *   instanceId?: string,
- *   tileUrlFunction: (tileCoord: number[] | null) => string | undefined,
- *   loadTileData: (tileCoord: number[], url: string | undefined) => Promise<ArrayBuffer | Uint8Array | null>,
- *   sourceOptions?: Record<string, unknown>,
- *   styleDocument: Record<string, unknown>,
- *   onTileLoadStart?: () => void,
- *   onTileLoadEnd?: () => void,
- *   onTileLoadError?: () => void
- * }} options
- * @returns {{ layer: VectorTileLayer, source: VectorTileSource, attachMap: () => void, detachMap: () => void, refresh: () => void, destroy: () => void }}
- */
 export function createMapZeroLabelLayer(options) {
   // The geometry layer already decodes every map layer. Labels only need these
   // source layers, so do not create Canvas features for buildings, water or
@@ -199,7 +81,7 @@ export function createMapZeroLabelLayer(options) {
   if (options.onTileLoadEnd) source.on('tileloadend', options.onTileLoadEnd);
   if (options.onTileLoadError) source.on('tileloaderror', options.onTileLoadError);
 
-  const styleCache = new Map();
+  const styleCache = new LruCache(2048);
   const layer = new VectorTileLayer({
     source,
     declutter: true,
@@ -225,60 +107,13 @@ export function createMapZeroLabelLayer(options) {
       layer.changed();
     },
     destroy() {
+      styleCache.clear();
       source.clear();
       layer.dispose();
     }
   };
 }
 
-/**
- * Return source MVT layer ids needed by the label renderer.
- *
- * @param {Array<{ id: string, type?: string, style?: string }>} orderedLayers
- * @param {Record<string, unknown>} styleDocument
- * @param {Map<string, boolean>} layerVisibility
- * @param {number} zoom
- * @returns {string[]}
- */
-export function activeLabelLayerIdsForZoom(orderedLayers, styleDocument, layerVisibility, zoom) {
-  const labels = labelConfigRoot(styleDocument);
-  if (!labels || labels.enabled === false) {
-    return [];
-  }
-
-  return LABEL_SOURCE_LAYERS.filter((layerId) => {
-    const rule = labelRuleForSource(styleDocument, layerId);
-    if (!rule || rule.enabled === false) {
-      return false;
-    }
-
-    if (!orderedLayers.some((layer) => layer.id === layerId) || !layerVisibility.get(layerId)) {
-      return false;
-    }
-
-    return zoomInRule(zoom, rule);
-  });
-}
-
-/**
- * @param {Record<string, unknown>} styleDocument
- * @returns {boolean}
- */
-export function hasEnabledLabels(styleDocument) {
-  const labels = labelConfigRoot(styleDocument);
-  return Boolean(labels && labels.enabled !== false && LABEL_SOURCE_LAYERS.some((layerId) => {
-    const rule = labelRuleForSource(styleDocument, layerId);
-    return rule && rule.enabled !== false;
-  }));
-}
-
-/**
- * @param {Feature} feature
- * @param {number} resolution
- * @param {Record<string, unknown>} styleDocument
- * @param {Map<string, Style>} styleCache
- * @returns {Style | null}
- */
 function labelStyle(feature, resolution, styleDocument, styleCache) {
   const zoom = resolutionToZoom(resolution);
   const sourceLayer = cleanText(feature.get('sourceLayer'));
@@ -301,42 +136,6 @@ function labelStyle(feature, resolution, styleDocument, styleCache) {
   return null;
 }
 
-/**
- * @param {Feature} feature
- * @returns {boolean}
- */
-function isPoiLikeFeature(feature) {
-  return [
-    'poi_category',
-    'amenity',
-    'tourism',
-    'shop',
-    'leisure',
-    'railway',
-    'public_transport',
-    'station',
-    'power',
-    'man_made',
-    'tower:type',
-    'military',
-    'emergency',
-    'office',
-    'government',
-    'boundary',
-    'protect_class',
-    'landuse',
-    'industrial'
-  ].some((property) => cleanText(feature.get(property)));
-}
-
-/**
- * @param {Feature} feature
- * @param {string} sourceLayer
- * @param {number} zoom
- * @param {Record<string, unknown>} styleDocument
- * @param {Map<string, Style>} styleCache
- * @returns {Style | null}
- */
 function candidateLabelStyle(feature, sourceLayer, zoom, styleDocument, styleCache) {
   const rule = labelRuleForSource(styleDocument, sourceLayer);
   const minZoom = Number(feature.get('minZoom') ?? rule?.minZoom ?? 0);
@@ -365,28 +164,6 @@ function candidateLabelStyle(feature, sourceLayer, zoom, styleDocument, styleCac
   });
 }
 
-/**
- * @param {Feature} feature
- * @param {Record<string, unknown>} rule
- * @returns {boolean}
- */
-function isSelectedPoiCandidate(feature, rule) {
-  const className = cleanText(feature.get('class'));
-  if (!className || ['clinic', 'pharmacy', 'fuel', 'charging_station', 'fire_hydrant', 'defibrillator', 'fire_extinguisher', 'restaurant', 'cafe', 'bar', 'fast_food', 'pub'].includes(className)) {
-    return false;
-  }
-
-  const selected = objectRule(rule.classes) ?? DEFAULT_POI_CLASSES;
-  return Object.values(selected).some((values) => Array.isArray(values) && values.map(String).includes(className));
-}
-
-/**
- * @param {Feature} feature
- * @param {number} zoom
- * @param {Record<string, unknown>} styleDocument
- * @param {Map<string, Style>} styleCache
- * @returns {Style | null}
- */
 function roadLabelStyle(feature, zoom, styleDocument, styleCache) {
   const rule = labelRuleForSource(styleDocument, ROAD_SOURCE_LAYER);
   if (!rule || rule.enabled === false || !zoomInRule(zoom, rule)) {
@@ -411,13 +188,6 @@ function roadLabelStyle(feature, zoom, styleDocument, styleCache) {
   });
 }
 
-/**
- * @param {Feature} feature
- * @param {number} zoom
- * @param {Record<string, unknown>} styleDocument
- * @param {Map<string, Style>} styleCache
- * @returns {Style | null}
- */
 function aviationLabelStyle(feature, zoom, styleDocument, styleCache) {
   const rule = labelRuleForSource(styleDocument, 'aip');
   if (!rule || rule.enabled === false || !zoomInRule(zoom, rule)) {
@@ -442,13 +212,6 @@ function aviationLabelStyle(feature, zoom, styleDocument, styleCache) {
   });
 }
 
-/**
- * @param {Feature} feature
- * @param {number} zoom
- * @param {Record<string, unknown>} styleDocument
- * @param {Map<string, Style>} styleCache
- * @returns {Style | null}
- */
 function poiLabelStyle(feature, zoom, styleDocument, styleCache) {
   const rule = labelRuleForSource(styleDocument, POI_SOURCE_LAYER);
   if (!rule || rule.enabled === false || !zoomInRule(zoom, rule) || !isSelectedPoi(feature, rule)) {
@@ -472,107 +235,6 @@ function poiLabelStyle(feature, zoom, styleDocument, styleCache) {
   });
 }
 
-/**
- * @param {Feature} feature
- * @param {string} highway
- * @param {number} zoom
- * @param {Record<string, unknown>} rule
- * @returns {{ text: string, priorityClass: string, zIndex: number } | null}
- */
-function roadLabel(feature, highway, zoom, rule) {
-  if (!highway || DISABLED_ROADS.has(highway)) {
-    return null;
-  }
-
-  const local = objectRule(rule.local);
-  if (LOCAL_ROADS.has(highway) && local?.enabled !== true) {
-    return null;
-  }
-
-  const ref = cleanText(feature.get('ref'));
-  const name = cleanText(feature.get('name'));
-
-  if (MAJOR_ROADS.has(highway)) {
-    const minZoom = Number(rule.majorMinZoom ?? 12);
-    if (zoom < minZoom || !isMeaningfulLabel(ref)) return null;
-    return { text: ref, priorityClass: 'important', zIndex: 820 };
-  }
-
-  if (SECONDARY_ROADS.has(highway)) {
-    const minZoom = Number(rule.secondaryMinZoom ?? 16);
-    if (zoom < minZoom || !isMeaningfulLabel(ref)) return null;
-    return { text: ref, priorityClass: 'normal', zIndex: 700 };
-  }
-
-  if (LOCAL_ROADS.has(highway)) {
-    const minZoom = Number(local?.minZoom ?? 17);
-    if (zoom < minZoom || !isMeaningfulLabel(name)) return null;
-    return { text: name, priorityClass: 'low', zIndex: 400 };
-  }
-
-  return null;
-}
-
-/**
- * @param {Feature} feature
- * @param {string} aeroway
- * @param {number} zoom
- * @returns {{ text: string, placement: 'line' | 'point', priorityClass: string, zIndex: number } | null}
- */
-function aviationLabel(feature, aeroway, zoom) {
-  if (!aeroway) {
-    return null;
-  }
-
-  const ref = cleanText(feature.get('ref'));
-  const name = cleanText(feature.get('name'));
-
-  if (aeroway === 'aerodrome' || aeroway === 'heliport') {
-    const text = name || aviationRefText(ref) || aviationFallbackText(aeroway);
-    return isRenderableAviationText(text, aeroway) && zoom >= 9
-      ? { text, placement: 'point', priorityClass: 'critical', zIndex: 980 }
-      : null;
-  }
-
-  if (aeroway === 'runway') {
-    const text = aviationRefText(ref) || name || 'RWY';
-    return isRenderableAviationText(text, aeroway) && zoom >= 11 ? { text, placement: 'line', priorityClass: 'important', zIndex: 900 } : null;
-  }
-
-  if (aeroway === 'terminal' || aeroway === 'apron') {
-    const text = name || ref || aviationFallbackText(aeroway);
-    return isMeaningfulLabel(text) && zoom >= 14 ? { text, placement: 'point', priorityClass: 'normal', zIndex: 720 } : null;
-  }
-
-  if (aeroway === 'helipad') {
-    const text = aviationRefText(ref) || name || 'H';
-    return isRenderableAviationText(text, aeroway) && zoom >= 12 ? { text, placement: 'point', priorityClass: 'critical', zIndex: 980 } : null;
-  }
-
-  return null;
-}
-
-function aviationFallbackText(aeroway) {
-  if (aeroway === 'aerodrome') return 'Aerodrome';
-  if (aeroway === 'heliport') return 'Heliport';
-  if (aeroway === 'terminal') return 'Terminal';
-  if (aeroway === 'apron') return 'Apron';
-  return cleanText(aeroway).replace(/_/g, ' ');
-}
-
-/**
- * @param {{
- *   cache: Map<string, Style>,
- *   styleDocument: Record<string, unknown>,
- *   rule: Record<string, unknown>,
- *   text: string,
- *   placement: 'line' | 'point',
- *   priorityClass: string,
- *   zIndex: number,
- *   zoom: number
- * }} options
- * @returns {Style}
- */
 function textStyle(options) {
   const priorityRule = priorityClassRule(options.styleDocument, options.priorityClass);
   const opacity = labelOpacityForZoom(options.zoom, Number(priorityRule.opacity ?? options.rule.opacity ?? 0.82));
@@ -609,460 +271,3 @@ function textStyle(options) {
   options.cache.set(key, style);
   return style;
 }
-
-/**
- * @param {Feature} feature
- * @param {Record<string, unknown>} rule
- * @returns {boolean}
- */
-function isSelectedPoi(feature, rule) {
-  const categories = objectRule(rule.categories);
-  const category = poiCategoryForFeature(feature);
-  if (category && categories?.[category] === false) {
-    return false;
-  }
-
-  const matchesClass = matchesSelectedPoiClass(feature, rule);
-  return matchesClass;
-}
-
-/**
- * @param {Feature} feature
- * @param {Record<string, unknown>} rule
- * @returns {boolean}
- */
-function matchesSelectedPoiClass(feature, rule) {
-  const selected = objectRule(rule.classes) ?? DEFAULT_POI_CLASSES;
-  for (const property of [
-    'amenity',
-    'tourism',
-    'shop',
-    'leisure',
-    'railway',
-    'public_transport',
-    'station',
-    'aeroway',
-    'power',
-    'man_made',
-    'tower:type',
-    'military',
-    'emergency',
-    'office',
-    'government',
-    'boundary',
-    'protect_class',
-    'landuse',
-    'industrial'
-  ]) {
-    const value = String(feature.get(property) ?? '');
-    const allowed = Array.isArray(selected[property]) ? /** @type {unknown[]} */ (selected[property]).map(String) : [];
-    if (value && allowed.includes(value)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-/**
- * @param {Feature} feature
- * @returns {string}
- */
-function poiLabelText(feature) {
-  for (const field of LABEL_TEXT_FIELDS) {
-    const text = cleanText(feature.get(field));
-    if (isMeaningfulLabel(text)) {
-      return text;
-    }
-  }
-
-  return poiFallbackLabel(feature);
-}
-
-function poiFallbackLabel(feature) {
-  const candidates = [
-    ['military', {
-      airbase: 'Airbase',
-      airfield: 'Airfield',
-      barracks: 'Barracks',
-      bunker: 'Bunker',
-      checkpoint: 'Checkpoint',
-      naval_base: 'Naval base',
-      range: 'Range',
-      training_area: 'Training area',
-      danger_area: 'Danger area',
-      ammunition_dump: 'Ammunition dump',
-      base: 'Base'
-    }],
-    ['emergency', {
-      ambulance_station: 'Ambulance station',
-      siren: 'Siren',
-      assembly_point: 'Assembly point',
-      disaster_response: 'Disaster response'
-    }],
-    ['amenity', {
-      hospital: 'Hospital',
-      police: 'Police',
-      fire_station: 'Fire station',
-      shelter: 'Shelter',
-      bunker: 'Bunker',
-      checkpoint: 'Checkpoint',
-      depot: 'Depot',
-      warehouse: 'Warehouse',
-      prison: 'Prison',
-      courthouse: 'Courthouse',
-      townhall: 'Town hall',
-      bus_station: 'Bus station',
-      ferry_terminal: 'Ferry terminal'
-    }],
-    ['power', {
-      plant: 'Power plant',
-      substation: 'Substation',
-      generator: 'Generator',
-      tower: 'Power tower',
-      transformer: 'Transformer',
-      line: 'Power line'
-    }],
-    ['man_made', {
-      communications_tower: 'Comms tower',
-      mast: 'Mast',
-      antenna: 'Antenna'
-    }],
-    ['boundary', {
-      protected_area: 'Protected area'
-    }],
-    ['landuse', {
-      industrial: 'Industrial'
-    }],
-    ['industrial', {
-      refinery: 'Refinery',
-      depot: 'Depot',
-      storage: 'Storage',
-      logistics: 'Logistics'
-    }]
-  ];
-
-  for (const [property, labels] of candidates) {
-    const value = cleanText(feature.get(property));
-    if (value && labels[value]) {
-      return labels[value];
-    }
-  }
-
-  const category = poiCategoryForFeature(feature);
-  return category === 'consumer' ? '' : titleCase(category);
-}
-
-/**
- * @param {Feature} feature
- * @returns {string}
- */
-function poiCategoryForFeature(feature) {
-  const existing = cleanText(feature.get('poi_category'));
-  if (existing) {
-    return existing;
-  }
-
-  const amenity = cleanText(feature.get('amenity'));
-  const tourism = cleanText(feature.get('tourism'));
-  const shop = cleanText(feature.get('shop'));
-  const leisure = cleanText(feature.get('leisure'));
-  const railway = cleanText(feature.get('railway'));
-  const publicTransport = cleanText(feature.get('public_transport'));
-  const station = cleanText(feature.get('station'));
-  const aeroway = cleanText(feature.get('aeroway'));
-  const power = cleanText(feature.get('power'));
-  const manMade = cleanText(feature.get('man_made'));
-  const towerType = cleanText(feature.get('tower:type'));
-  const military = cleanText(feature.get('military'));
-  const emergency = cleanText(feature.get('emergency'));
-  const office = cleanText(feature.get('office'));
-  const government = cleanText(feature.get('government'));
-  const boundary = cleanText(feature.get('boundary'));
-  const protectClass = cleanText(feature.get('protect_class'));
-  const landuse = cleanText(feature.get('landuse'));
-  const industrial = cleanText(feature.get('industrial'));
-
-  if (['railway_station', 'train_station', 'subway_station', 'bus_station', 'ferry_terminal', 'airport'].includes(amenity) ||
-    railway === 'station' || publicTransport === 'station' || station === 'subway' || aeroway === 'aerodrome' || aeroway === 'airport') {
-    return 'transport';
-  }
-  if (['hospital', 'police', 'fire_station', 'shelter'].includes(amenity) || ['ambulance_station', 'siren', 'assembly_point', 'disaster_response'].includes(emergency)) return 'emergency';
-  if (['townhall', 'courthouse', 'prison', 'embassy'].includes(amenity) || office === 'government' || government) return 'government';
-  if (power) return 'energy';
-  if (amenity === 'communications_tower' || manMade === 'communications_tower' || manMade === 'mast' || manMade === 'antenna' || towerType === 'communication') return 'communications';
-  if (boundary === 'protected_area' || leisure === 'nature_reserve' || tourism === 'national_park' || protectClass) return 'protected';
-  if (landuse === 'industrial' || industrial || ['depot', 'warehouse'].includes(amenity)) return 'industrial';
-  if (military || ['bunker', 'checkpoint'].includes(amenity)) return 'military';
-  if (shop || tourism || leisure || ['restaurant', 'cafe', 'bar', 'fast_food', 'pub'].includes(amenity)) return 'consumer';
-  return 'operational';
-}
-
-/**
- * @param {number} priority
- * @returns {string}
- */
-function priorityClassFromNumber(priority) {
-  if (priority >= 900) return 'critical';
-  if (priority >= 760) return 'important';
-  if (priority >= 500) return 'normal';
-  return 'low';
-}
-
-/**
- * @param {Feature} feature
- * @returns {string}
- */
-function poiPriorityClass(feature) {
-  const category = String(feature.get('poi_category') ?? '');
-  if (category === 'emergency' || category === 'military') {
-    return 'critical';
-  }
-  if (['transport', 'energy', 'communications', 'government'].includes(category)) {
-    return 'important';
-  }
-
-  const amenity = String(feature.get('amenity') ?? '');
-  if (amenity === 'hospital' || amenity === 'police' || amenity === 'fire_station') {
-    return 'critical';
-  }
-  return 'normal';
-}
-
-/**
- * @param {Feature} feature
- * @returns {number}
- */
-function poiZIndex(feature) {
-  const priority = poiPriorityClass(feature);
-  if (priority === 'critical') return 920;
-  if (priority === 'important') return 820;
-  return 620;
-}
-
-/**
- * @param {Record<string, unknown>} rule
- * @param {Record<string, unknown>} priorityRule
- * @param {number} zoom
- * @returns {string}
- */
-function labelFont(rule, priorityRule, zoom) {
-  const configured = String(priorityRule.font ?? rule.font ?? '').trim();
-  if (configured) {
-    return configured;
-  }
-
-  const weight = String(priorityRule.weight ?? rule.weight ?? 600);
-  const size = zoom >= 17 ? 12 : zoom >= 15 ? 11 : 10;
-  return `${weight} ${size}px sans-serif`;
-}
-
-/**
- * @param {Record<string, unknown>} styleDocument
- * @param {string} className
- * @returns {Record<string, unknown>}
- */
-function priorityClassRule(styleDocument, className) {
-  const labels = labelConfigRoot(styleDocument);
-  const classes = labels?.priorityClasses && typeof labels.priorityClasses === 'object'
-    ? /** @type {Record<string, unknown>} */ (labels.priorityClasses)
-    : {};
-  const rule = classes[className];
-  return rule && typeof rule === 'object' ? /** @type {Record<string, unknown>} */ (rule) : {};
-}
-
-/**
- * @param {number} zoom
- * @param {number} base
- * @returns {number}
- */
-function labelOpacityForZoom(zoom, base) {
-  if (zoom < 12.5) return base * 0.6;
-  if (zoom < 14) return base * 0.76;
-  return base;
-}
-
-/**
- * @param {unknown} value
- * @returns {string}
- */
-function cleanText(value) {
-  return String(value ?? '').replace(/\s+/g, ' ').trim();
-}
-
-function titleCase(value) {
-  return cleanText(value)
-    .replace(/_/g, ' ')
-    .replace(/\b\w/g, (char) => char.toUpperCase());
-}
-
-/**
- * @param {string} text
- * @returns {boolean}
- */
-function isMeaningfulLabel(text) {
-  const normalized = cleanText(text);
-  if (normalized.length < 2) {
-    return false;
-  }
-
-  const key = normalized.toLowerCase().replace(/\s+/g, '_');
-  if (GENERIC_LABEL_VALUES.has(key)) {
-    return false;
-  }
-
-  if (/^(yes|no|true|false|0|1)$/i.test(normalized)) {
-    return false;
-  }
-
-  return true;
-}
-
-/**
- * @param {Feature} feature
- * @param {string} sourceLayer
- * @param {string} text
- * @returns {boolean}
- */
-function isExplicitAviationLabel(feature, sourceLayer, text) {
-  if (!AIP_SOURCE_LAYERS.has(sourceLayer)) {
-    return false;
-  }
-
-  const aeroway = cleanText(feature.get('aeroway') || feature.get('class'));
-  if (text === 'H') {
-    return aeroway === 'helipad' || aeroway === 'heliport';
-  }
-
-  if (text === 'RWY') {
-    return aeroway === 'runway';
-  }
-
-  return /^[A-Z]$/.test(text) && ['helipad', 'heliport', 'runway'].includes(aeroway);
-}
-
-/**
- * @param {string} ref
- * @returns {string}
- */
-function aviationRefText(ref) {
-  return ref && !/^(yes|no|true|false|0|1)$/i.test(ref) ? ref : '';
-}
-
-/**
- * @param {string} text
- * @param {string} aeroway
- * @returns {boolean}
- */
-function isRenderableAviationText(text, aeroway) {
-  if (isMeaningfulLabel(text)) {
-    return true;
-  }
-
-  if (text === 'H') {
-    return aeroway === 'helipad' || aeroway === 'heliport';
-  }
-
-  if (text === 'RWY') {
-    return aeroway === 'runway';
-  }
-
-  return /^[A-Z]$/.test(text) && ['helipad', 'heliport', 'runway'].includes(aeroway);
-}
-
-/**
- * @param {Record<string, unknown>} styleDocument
- * @returns {Record<string, unknown> | null}
- */
-function labelConfigRoot(styleDocument) {
-  return styleDocument.labels && typeof styleDocument.labels === 'object'
-    ? /** @type {Record<string, unknown>} */ (styleDocument.labels)
-    : null;
-}
-
-/**
- * @param {Record<string, unknown>} styleDocument
- * @param {string} sourceLayer
- * @returns {Record<string, unknown> | null}
- */
-function labelRuleForSource(styleDocument, sourceLayer) {
-  const labels = labelConfigRoot(styleDocument);
-  const rule = labels?.[sourceLayer] ?? labels?.[labelSourceAlias(sourceLayer)];
-  return rule && typeof rule === 'object' ? /** @type {Record<string, unknown>} */ (rule) : null;
-}
-
-/**
- * @param {string} sourceLayer
- * @returns {string}
- */
-function labelSourceAlias(sourceLayer) {
-  if (sourceLayer === 'aip') return 'aviation';
-  if (sourceLayer === 'aviation') return 'aip';
-  return sourceLayer;
-}
-
-/**
- * @param {unknown} rule
- * @returns {Record<string, unknown> | null}
- */
-function objectRule(rule) {
-  return rule && typeof rule === 'object' ? /** @type {Record<string, unknown>} */ (rule) : null;
-}
-
-/**
- * @param {number} zoom
- * @param {Record<string, unknown>} rule
- * @returns {boolean}
- */
-function zoomInRule(zoom, rule) {
-  const minZoom = Number(rule.minZoom ?? 0);
-  const maxZoom = Number(rule.maxZoom ?? 22);
-  return (!Number.isFinite(minZoom) || zoom >= minZoom) && (!Number.isFinite(maxZoom) || zoom <= maxZoom);
-}
-
-/**
- * @param {number} resolution
- * @returns {number}
- */
-function resolutionToZoom(resolution) {
-  const initialResolution = 156543.03392804097;
-  return Math.log2(initialResolution / Number(resolution));
-}
-
-/**
- * @param {string} color
- * @param {number} opacity
- * @returns {string}
- */
-function rgba(color, opacity) {
-  const rgb = hexToRgb(color);
-  if (!rgb) {
-    return color;
-  }
-  return `rgba(${rgb[0]}, ${rgb[1]}, ${rgb[2]}, ${clamp(opacity, 0, 1)})`;
-}
-
-/**
- * @param {string} color
- * @returns {[number, number, number] | null}
- */
-function hexToRgb(color) {
-  const match = /^#?([0-9a-f]{6})$/i.exec(color);
-  if (!match) {
-    return null;
-  }
-  const value = Number.parseInt(match[1], 16);
-  return [(value >> 16) & 255, (value >> 8) & 255, value & 255];
-}
-
-/**
- * @param {number} value
- * @param {number} min
- * @param {number} max
- * @returns {number}
- */
-function clamp(value, min, max) {
-  if (!Number.isFinite(value)) {
-    return min;
-  }
-  return Math.max(min, Math.min(max, value));
-}