leaflet-city-mapper 0.0.6 → 0.0.8

package/src/vector-tiles/vectorTilePaint.js

@@ -0,0 +1,10 @@
+import { vectorPaint } from '../vector-style/vectorPaint.js';
+import { visibleStyle } from '../vector-style/visibleStyle.js';
+
+export function vectorTilePaint(batch, zoom) {
+  const paint = vectorPaint(batch.entry, batch.properties, zoom);
+  if (!visibleStyle(batch.entry, batch.properties, zoom)) {
+    paint.opacity = 0; paint.fillOpacity = 0;
+  }
+  return paint;
+}

package/src/vector-tiles/vectorTileSettings.js

@@ -0,0 +1,17 @@
+import { readTileJSON } from './readTileJSON.js';
+import { readVectorStyle } from './readVectorStyle.js';
+import { validateVectorTileZooms } from './validateVectorTileZooms.js';
+
+export async function vectorTileSettings(options) {
+  if (!options || typeof options !== 'object') throw /* alloc */ new TypeError('Vector tiles require source options');
+  if (options.tileJSON) options = await readTileJSON(options);
+  let { url, style, minNativeZoom = 0, maxNativeZoom = 14, maxZoom = 19 } = options;
+  let key;
+  if (typeof url === 'string') url = url.replaceAll(/%7B([zxy])%7D/gi, '{$1}');
+  for (key of /* alloc */ ['{z}', '{x}', '{y}']) {
+    if (typeof url !== 'string' || !url.includes(key)) throw /* alloc */ new Error('Vector tiles require an XYZ URL template');
+  }
+  validateVectorTileZooms(minNativeZoom, maxNativeZoom, maxZoom);
+  style = await readVectorStyle(style);
+  return /* alloc */ { ...options, url, style, minNativeZoom, maxNativeZoom, maxZoom };
+}

package/src/vector-tiles/vectorTilesIdle.js

@@ -0,0 +1,3 @@
+export function vectorTilesIdle(layer, session) {
+  return layer.session === session && performance.now() - (layer.changedAt || 0) >= 180;
+}

package/src/vector-tiles/vectorTolerance.js

@@ -0,0 +1,4 @@
+/** Simplification tolerance in tile units: about 0.7 screen pixels at the displayed scale. */
+export function vectorTolerance(job, layer) {
+  return layer.extent / 256 / 2 ** Math.max(-1, job.mapZoom - job.coords.z) * 0.7;
+}

package/src/vector-tiles/wrapVectorLabel.js

@@ -0,0 +1,11 @@
+/** Greedy word wrap at 10 ems (MapLibre's default text-max-width), estimating glyph width at 0.52 em. */
+export function wrapVectorLabel(text) {
+  const limit = Math.floor(10 / 0.52), lines = /* alloc */ [];
+  let line = '', word;
+  for (word of text.split(' ')) {
+    if (line && Array.from(`${line} ${word}`).length > limit) { lines.push(line); line = word; }
+    else line = line ? `${line} ${word}` : word;
+  }
+  lines.push(line);
+  return lines;
+}

package/src/walk/initWalk.js

@@ -2,6 +2,7 @@ import { L } from '../globals/L.js';
 import { initialize } from './initializeWalkControl.js';
 import { onAdd } from './onAddWalkControl.js';
 import { onRemove } from './onRemoveWalkControl.js';
+import { extendLeafletClass } from '../core/extendLeafletClass.js';
 
 /**
  * Third-person walk mode, toggled by a map button (and Esc): a pedestrian at the map centre runs with W/S (or ↑/↓) and
@@ -11,9 +12,21 @@ import { onRemove } from './onRemoveWalkControl.js';
  * Options: `speed` (m/s, default 70), `distance` (camera distance in metres, default 20), `position` (button corner, default 'bottomright').
  * Buildings, trees, models, streetlights and traffic block movement; the walker is moved out of newly loaded obstacles.
  */
-L.Control.Walk = L.Control.extend({
-  options: { position: 'bottomright', speed: 70, distance: 20 },
-  initialize,
-  onAdd,
-  onRemove,
-});
+class WalkControl extends extendLeafletClass(L.Control) {
+  static initHooks = true;
+  static defaultOptions = { position: 'bottomright', speed: 70, distance: 20 };
+
+  constructor(options) {
+    super(options);
+    if (L.version.startsWith('2.')) {
+      initialize.call(this, options);
+      this.callInitHooks();
+    }
+  }
+}
+Object.assign(WalkControl.prototype, { onAdd, onRemove });
+if (L.version.startsWith('1.')) {
+  WalkControl.prototype.options = Object.assign(Object.create(L.Control.prototype.options), WalkControl.defaultOptions);
+  WalkControl.prototype.initialize = initialize;
+}
+L.Control.Walk = WalkControl;

package/src/weakmaps/nativeProgramsByRenderer.js

@@ -0,0 +1 @@
+export const nativeProgramsByRenderer = new WeakMap();

package/src/weakmaps/pathProjectionByMap.js

@@ -0,0 +1 @@
+export const pathProjectionByMap = new WeakMap();

package/src/weakmaps/streamTerrainByLayer.js

@@ -0,0 +1 @@
+export const streamTerrainByLayer = new WeakMap();

package/src/weakmaps/streamTerrainByMap.js

@@ -0,0 +1 @@
+export const streamTerrainByMap = new WeakMap();

package/src/weakmaps/vectorTileOptionsByLayer.js

@@ -0,0 +1 @@
+export const vectorTileOptionsByLayer = new WeakMap();

package/src/weakmaps/vectorWorkerByLayer.js

@@ -0,0 +1 @@
+export const vectorWorkerByLayer = new WeakMap();

package/src/weakmaps/workerMapByLayer.js

@@ -0,0 +1 @@
+export const workerMapByLayer = new WeakMap();

package/src/workers/buildAreaInWorker.js

@@ -1,40 +1,16 @@
-import { geometryWorkerUrl } from '../globals/geometryWorkerUrl.js';
-import { startGeometryWorker } from './startGeometryWorker.js';
-import { acquireGeometryWorker } from './acquireGeometryWorker.js';
+import { runSourceWorker } from './runSourceWorker.js';
 
 export async function buildAreaInWorker(context, signal) {
-  const entry = acquireGeometryWorker(context.map || context.backend._map, context.backend.options.workerUrl || geometryWorkerUrl);
-  const { worker, pool } = entry;
-  const task = /* alloc */ {
-    worker, signal,
-    input: /* alloc */ { jobs: context.jobs, nightLight: Boolean(context.backend.options.nightLight) },
-  };
-  entry.task = task;
-  let completed = false;
   try {
-    const data = await /* alloc */ new Promise(startGeometryWorker.bind(null, task));
+    const data = await runSourceWorker(context.map || context.backend._map, context.backend.options.workerUrl,
+      /* alloc */ { jobs: context.jobs, nightLight: Boolean(context.backend.options.nightLight) }, signal);
     let i;
     for (i = 0; i < data.ranges.length; i++) Object.assign(context.featureFaces[i], data.ranges[i]);
     context.positions = data.positions;
     context.uvs = data.uvs;
     context.lights = data.lights;
     context.preparedGeometry = data;
-    completed = true;
   } finally {
-    worker.removeEventListener('message', task.onEvent);
-    worker.removeEventListener('error', task.onEvent);
-    worker.removeEventListener('messageerror', task.onEvent);
-    signal.removeEventListener('abort', task.onEvent);
-    entry.task = null;
-    if (completed && pool && !pool.closed && !signal.aborted) pool.idle.push(entry);
-    else {
-      if (!entry.closed) worker.terminate();
-      if (pool) pool.entries.delete(entry);
-    }
-    if (entry.blobUrl) {
-      URL.revokeObjectURL(entry.blobUrl);
-      entry.blobUrl = null;
-    }
     context.jobs = null;
   }
 }

package/src/workers/cogWorker.js

@@ -0,0 +1,20 @@
+import { openCog } from '../cog/openCog.js';
+import { workerCogSource } from '../globals/workerCogSource.js';
+
+export async function onCogMessage({ data }) {
+  try {
+    const key = JSON.stringify(/* alloc */ [data.url, data.asset]);
+    if (!workerCogSource.has(key)) {
+      workerCogSource.set(key, openCog(data.url, data.asset));
+      if (workerCogSource.size > 4) workerCogSource.delete(workerCogSource.keys().next().value);
+    }
+    const archive = await workerCogSource.get(key);
+    const result = data.z === undefined ? await archive.getHeader() : await archive.getZxy(data.z, data.x, data.y);
+    const transfers = /* alloc */ [];
+    if (result?.data) transfers.push(result.data);
+    if (result?.image) transfers.push(result.image);
+    self.postMessage(result, transfers);
+  } catch (error) {
+    self.postMessage(/* alloc */ { error: /* alloc */ { name: error.name, message: error.message } });
+  }
+}

package/src/workers/createGeometryWorker.js

@@ -1,4 +1,5 @@
 export function createGeometryWorker(url, pool) {
+  if (typeof Worker === 'undefined') throw /* alloc */ new Error('Web Workers are required to prepare source geometry');
   let workerUrl = url, blobUrl, worker;
   if (globalThis.location) {
     const resolved = /* alloc */ new URL(url, location.href);

package/src/workers/geometryWorker.js

@@ -1,6 +1,21 @@
 import { assembleAreaGeometry } from '../geometry/assembleAreaGeometry.js';
+import { onVectorTileMessage } from './vectorTileWorker.js';
+import { onCogMessage } from './cogWorker.js';
+import { onModelMessage } from './modelWorker.js';
 
 export function onGeometryMessage(event) {
+  if (event.data.type === 'model') {
+    onModelMessage(event);
+    return;
+  }
+  if (event.data.type === 'cog') {
+    onCogMessage(event);
+    return;
+  }
+  if (event.data.type === 'vector') {
+    onVectorTileMessage(event);
+    return;
+  }
   try {
     const data = assembleAreaGeometry(event.data);
     const transfers = /* alloc */ [data.positions.buffer, data.normals.buffer, data.colors.buffer, data.uvs.buffer];

package/src/workers/getCogInWorker.js

@@ -0,0 +1,7 @@
+import { workerMapByLayer } from '../weakmaps/workerMapByLayer.js';
+import { runSourceWorker } from './runSourceWorker.js';
+
+export function getCogInWorker(context, z, x, y, signal) {
+  return runSourceWorker(context.layer._map || workerMapByLayer.get(context.layer), context.workerUrl,
+    /* alloc */ { type: 'cog', url: context.url, asset: context.asset, z, x, y }, signal);
+}

package/src/workers/modelWorker.js

@@ -0,0 +1,10 @@
+import { prepareModel } from '../models/prepareModel.js';
+
+export async function onModelMessage({ data }) {
+  try {
+    const result = await prepareModel(data.url);
+    self.postMessage(/* alloc */ { description: result.description, images: result.images }, result.transfers);
+  } catch (error) {
+    self.postMessage(/* alloc */ { error: /* alloc */ { name: error.name, message: error.message } });
+  }
+}

package/src/workers/openCogInWorker.js

@@ -0,0 +1,14 @@
+import { getCogHeader } from '../cog/getCogHeader.js';
+import { getCogInWorker } from './getCogInWorker.js';
+
+export async function openCogInWorker(layer, options) {
+  const context = /* alloc */ {
+    layer, url: /* alloc */ new URL(options.url, document.baseURI).href,
+    asset: options.asset, workerUrl: options.workerUrl,
+  };
+  const header = await getCogInWorker(context);
+  return /* alloc */ {
+    getHeader: getCogHeader.bind(null, /* alloc */ { header }),
+    getZxy: getCogInWorker.bind(null, context),
+  };
+}

package/src/workers/runSourceWorker.js

@@ -0,0 +1,32 @@
+import { geometryWorkerUrl } from '../globals/geometryWorkerUrl.js';
+import { startGeometryWorker } from './startGeometryWorker.js';
+import { acquireGeometryWorker } from './acquireGeometryWorker.js';
+
+export async function runSourceWorker(map, url, input, signal = /* alloc */ new AbortController().signal) {
+  signal.throwIfAborted();
+  const entry = acquireGeometryWorker(map, url || geometryWorkerUrl);
+  const { worker, pool } = entry;
+  const task = /* alloc */ { worker, signal, input };
+  entry.task = task;
+  let completed = false;
+  try {
+    const data = await /* alloc */ new Promise(startGeometryWorker.bind(null, task));
+    completed = true;
+    return data;
+  } finally {
+    worker.removeEventListener('message', task.onEvent);
+    worker.removeEventListener('error', task.onEvent);
+    worker.removeEventListener('messageerror', task.onEvent);
+    signal.removeEventListener('abort', task.onEvent);
+    entry.task = null;
+    if (completed && pool && !pool.closed && !signal.aborted) pool.idle.push(entry);
+    else {
+      if (!entry.closed) worker.terminate();
+      if (pool) pool.entries.delete(entry);
+    }
+    if (entry.blobUrl) {
+      URL.revokeObjectURL(entry.blobUrl);
+      entry.blobUrl = null;
+    }
+  }
+}

package/src/workers/settleGeometryWorker.js

@@ -2,7 +2,7 @@ export function settleGeometryWorker(task, event) {
   if (event.type === 'abort') task.reject(task.signal.reason);
   else if (event.type === 'error') task.reject(/* alloc */ new Error(`Geometry worker failed: ${event.message}`));
   else if (event.type === 'messageerror') task.reject(/* alloc */ new Error('Unable to receive geometry worker buffers'));
-  else if (event.data.error) {
+  else if (event.data?.error) {
     const error = /* alloc */ new Error(event.data.error.message);
     error.name = event.data.error.name;
     task.reject(error);

package/src/workers/vectorTileWorker.js

@@ -0,0 +1,10 @@
+import { prepareVectorTile } from '../vector-tiles/prepareVectorTile.js';
+
+export function onVectorTileMessage({ data }) {
+  try {
+    const result = prepareVectorTile(data.buffer, data.coords, data.style, data.zoom, data.source, data.maxZoom, data.mapZoom);
+    self.postMessage(/* alloc */ { id: data.id, ...result });
+  } catch (error) {
+    self.postMessage(/* alloc */ { id: data.id, error: error.message });
+  }
+}

package/src/geometry/buildExtrudedPolygon.js

@@ -1,10 +0,0 @@
-import { projectRing } from '../projections/projectRing.js';
-import { buildProjectedPolygon } from './buildProjectedPolygon.js';
-
-export function buildAreaPolygon(context, rings, top, bottom, baseColor) {
-  if (!rings.length) throw /* alloc */ new Error('Empty GeoJSON polygon');
-  const paths = /* alloc */ [];
-  let ring;
-  for (ring of rings) paths.push(projectRing(context, ring));
-  buildProjectedPolygon(context, paths, top, bottom, baseColor);
-}

package/src/globals/layerCallInitHooks.js

@@ -1 +0,0 @@
-export const layerCallInitHooks = { value: undefined };

package/src/sources/buildAreaPoint.js

@@ -1,7 +0,0 @@
-import { projectedTree } from '../projections/projectTreePoint.js';
-import { buildProjectedPoint } from '../geometry/buildProjectedPoint.js';
-
-export function buildAreaPoint(context, feature, lon, lat, style, baseColor) {
-  const projected = projectedTree(context, lon, lat);
-  buildProjectedPoint(context, projected, style, baseColor, feature.properties?.cod_ouvrag || `${lon},${lat}`);
-}