leaflet-city-mapper 0.0.2 → 0.0.4

package/src/sources/projectedTree.js

@@ -0,0 +1,19 @@
+import { L } from '../globals/L.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+import { getElevation } from '../terrain/getElevation.js';
+
+export function projectedTree(context, lon, lat) {
+  const { backend, crs, origin, metres, map } = context;
+  const location = /* alloc */ new L.LatLng(lat, lon);
+  const point = crs.project(location);
+  const elevation = cameraByMap.get(map)._terrain3D ? getElevation(cameraByMap.get(map)._terrain3D, location) : undefined;
+  return /* alloc */ {
+    x: (point.x - origin.x) * metres,
+    y: (point.y - origin.y) * metres,
+    ground: Number.isFinite(elevation) && Number.isFinite(sceneByLayer.get(backend).root.position[1])
+      ? elevation - sceneByLayer.get(backend).root.position[1] : 0,
+  };
+}

package/src/sources/pump.js

@@ -0,0 +1,44 @@
+import { renderers } from '../globals/renderers.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+
+import { emptyNode } from "../scene/emptyNode.js";
+import { isClockWise } from "../triangulation/isClockWise.js";
+import { lampPostGeometry } from "../geometry/lampPostGeometry.js";
+import { lightGeometry } from "../geometry/lightGeometry.js";
+import { parseColor } from "../utils/parseColor.js";
+import { treeGeometry } from "../geometry/treeGeometry.js";
+import { triangulate } from "../triangulation/triangulate.js";
+import { createProgram } from '../rendering/createProgram.js';
+import { updateStatus } from './updateStatus.js';
+import { loadSource } from '../archives/loadSource.js';
+import { setParent } from '../scene/setParent.js';
+import { update } from '../scene/update.js';
+import { getElevation } from "../terrain/getElevation.js";
+
+import { buildArea } from './buildArea.js';
+import { pendingSourceAreas } from './pendingSourceAreas.js';
+
+/** Share four load/build slots across source layers, nearest ground blocks first. */
+export function pump(backend, map = backend._map) {
+  const shared = map && renderers.get(map);
+  if (!shared) return;
+  const layers = /* alloc */ [];
+  let layer, area, areaBackend;
+  for (layer of sceneByLayer.get(shared)._layers) {
+    if (Number.isFinite(sceneByLayer.get(layer)._inflight) && sceneByLayer.get(layer)._areas && (sceneByLayer.get(layer).url || sceneByLayer.get(layer)._geojson)) layers.push(layer);
+  }
+  const pending = pendingSourceAreas(layers, map);
+  let inflight = 0;
+  for (layer of layers) inflight += sceneByLayer.get(layer)._inflight;
+  for ({ layer: areaBackend, area } of pending) {
+    if (inflight >= 4) break;
+    if (sceneByLayer.get(areaBackend)._inflight >= 2) continue;
+    area.started = true;
+    sceneByLayer.get(areaBackend)._inflight++;
+    inflight++;
+    buildArea(areaBackend, area, map);
+  }
+  for (layer of layers) updateStatus(layer);
+}

package/src/sources/releaseArea.js

@@ -0,0 +1,25 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+import { setHighlight } from '../picking/setHighlight.js';
+import { showFeature } from '../picking/showFeature.js';
+import { setParent } from '../scene/setParent.js';
+import { update } from '../scene/update.js';
+
+/** Cancel pending work and dispose this block's GPU data, including any hover highlight. */
+export function releaseArea(backend, area) {
+  area.request.abort();
+  let attribute;
+  if (area.mesh) {
+    if (sceneByLayer.get(backend).highlightedFeature?.mesh === area.mesh) {
+      setHighlight(backend, null);
+      sceneByLayer.get(backend).hoveredFeature = null;
+      showFeature(backend, null);
+    }
+    setParent(area.mesh, null);
+    update(backend);
+    const geometry = area.mesh.geometry;
+    for (attribute of Object.values(geometry.attributes)) attribute.buffer.destroy();
+    area.mesh.program.pipelineCache.clear();
+  }
+}

package/src/sources/setGeoJSONData.js

@@ -0,0 +1,15 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+import { releaseArea } from './releaseArea.js';
+import { updateArea } from './updateArea.js';
+
+export function setGeoJSONData(layer, data) {
+  layer.options.data = data;
+  delete layer.options.url;
+  let area;
+  for (area of sceneByLayer.get(layer)._areas.values()) releaseArea(layer, area);
+  sceneByLayer.get(layer)._areas.clear();
+  updateArea(layer);
+  return layer;
+}

package/src/sources/setGeoJSONLayerData.js

@@ -0,0 +1,5 @@
+import { setGeoJSONData } from './setGeoJSONData.js';
+
+export function setGeoJSONLayerData(data) {
+  return setGeoJSONData(this, data);
+}

package/src/sources/sourceAreaContext.js

@@ -0,0 +1,19 @@
+import { radians } from '../globals/radians.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+export function sourceAreaContext(backend, area, map) {
+  const crs = map.options.crs, origin = crs.project(sceneByLayer.get(backend).location);
+  return /* alloc */ {
+    backend, area, map, crs, origin,
+    metres: Math.cos(sceneByLayer.get(backend).location.lat * radians),
+    positions: /* alloc */ [],
+    normals: /* alloc */ [],
+    colors: /* alloc */ [],
+    uvs: /* alloc */ [],
+    featureFaces: /* alloc */ [],
+    lights: /* alloc */ [],
+    supports: /* alloc */ new Set(),
+    skipped: 0,
+  };
+}

package/src/sources/updateArea.js

@@ -0,0 +1,52 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+import { pump } from "./pump.js";
+import { releaseArea } from './releaseArea.js';
+import { compareAreaDistance } from './compareAreaDistance.js';
+
+/** Cover the visible ground bounds and one bordering block, clipped to the archive. */
+
+export function updateArea(backend) {
+  if (!backend._map || !sceneByLayer.get(backend)._shared) return;
+  if (sceneByLayer.get(backend)._geojson) {
+    if (!sceneByLayer.get(backend)._areas.has('geojson')) {
+      sceneByLayer.get(backend)._areas.set('geojson', /* alloc */ { request: /* alloc */ new AbortController() });
+    }
+    pump(backend);
+    return;
+  }
+  if (!sceneByLayer.get(backend).header) return;
+  const z = sceneByLayer.get(backend).header.minZoom;
+  const center = backend._map.project(backend._map.getCenter(), z).divideBy(256).floor();
+  const bounds = backend._map.getBounds();
+  const nw = backend._map.project(bounds.getNorthWest(), z).divideBy(256).floor();
+  const se = backend._map.project(bounds.getSouthEast(), z).divideBy(256).floor();
+  const archiveNW = backend._map.project(/* alloc */ [sceneByLayer.get(backend).header.maxLat, sceneByLayer.get(backend).header.minLon], z).divideBy(256).floor();
+  const archiveSE = backend._map.project(/* alloc */ [sceneByLayer.get(backend).header.minLat, sceneByLayer.get(backend).header.maxLon], z).divideBy(256).floor();
+  const wanted = /* alloc */ new Map();
+  let x, y, key, area, coords;
+  for (x = Math.max(0, nw.x - 1, archiveNW.x); x <= Math.min(2 ** z - 1, se.x + 1, archiveSE.x); x++) {
+    for (y = Math.max(0, nw.y - 1, archiveNW.y); y <= Math.min(2 ** z - 1, se.y + 1, archiveSE.y); y++) {
+      wanted.set(`${x}/${y}`, /* alloc */ { z, x, y });
+    }
+  }
+  for ([key, area] of sceneByLayer.get(backend)._areas) {
+    if (!wanted.has(key)) {
+      releaseArea(backend, area);
+      sceneByLayer.get(backend)._areas.delete(key);
+    }
+  }
+  // Load the nearest new blocks first without rebuilding retained geometry.
+  const areas = /* alloc */ [];
+  for ([key, coords] of wanted) {
+    coords.distance = Math.hypot(coords.x + 0.5 - center.x, coords.y + 0.5 - center.y) / 2 ** z;
+    areas.push(coords);
+  }
+  areas.sort(compareAreaDistance);
+  for (coords of areas) {
+    key = `${coords.x}/${coords.y}`;
+    if (!sceneByLayer.get(backend)._areas.has(key)) sceneByLayer.get(backend)._areas.set(key, /* alloc */ { coords, request: /* alloc */ new AbortController() });
+  }
+  pump(backend);
+}

package/src/sources/updateStatus.js

@@ -0,0 +1,15 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+/** Emit a snapshot for consumers; ready does not wait for all neighborhood tasks. */
+export function updateStatus(backend, enabled = true) {
+  const progress = /* alloc */ { enabled, loaded: 0, skipped: 0, pending: 0, errors: /* alloc */ [] };
+  let area;
+  for (area of sceneByLayer.get(backend)._areas.values()) {
+    if (area.error) progress.errors.push(area.error);
+    else if (!area.done) progress.pending++;
+    progress.loaded += area.buildings ?? 0;
+    progress.skipped += area.skipped ?? 0;
+  }
+  backend.fire('progress', progress);
+}

package/src/sunlight/addTimeLayer.js

@@ -0,0 +1,6 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+export function addTimeLayer(map) {
+  return sceneByLayer.get(this).control.addTo(map);
+}

package/src/sunlight/addTo.js

@@ -0,0 +1,11 @@
+import { L } from '../globals/L.js';
+import { underEntry } from '../scene/underEntry.js';
+import { styleTimeControl } from './styleTimeControl.js';
+
+export function addTo(map) {
+  L.Control.prototype.addTo.call(this, map);
+  const container = this.getContainer();
+  if (this.layer._map === map) underEntry(this.layer, container, styleTimeControl.bind(null, container));
+  else styleTimeControl(container, false);
+  return this;
+}

package/src/sunlight/atmosphere.js

@@ -0,0 +1,25 @@
+import { atmosphereStops } from '../globals/atmosphereStops.js';
+import { atmosphereColor } from '../globals/atmosphereColor.js';
+
+import { mix } from './mix.js';
+import { rgb } from './rgb.js';
+
+
+export function atmosphere(altitude) {
+  if (!Number.isFinite(altitude)) {
+    throw /* alloc */ new Error('Invalid solar altitude');
+  }
+  const stops = atmosphereStops;
+  let upper = -1;
+  let i;
+  for (i = 0; i < stops.length; i++) {
+    if (stops[i][0] >= altitude) { upper = i; break; }
+  }
+  const b = stops[upper < 0 ? stops.length - 1 : upper],
+        a = stops[Math.max(0, upper - 1)];
+  const t = a === b || upper < 0 ? 1 : (altitude - a[0]) / (b[0] - a[0]);
+  return /* alloc */ {
+    background: `linear-gradient(${rgb(mix(a[1], b[1], t, atmosphereColor))}, ${rgb(mix(a[2], b[2], t, atmosphereColor))})`,
+    tint: mix(a[3], b[3], t),
+  };
+}

package/src/sunlight/createSun.js

@@ -0,0 +1,54 @@
+import { L } from '../globals/L.js';
+import { updateSky } from './updateSky.js';
+import { updateSun } from './updateSun.js';
+import { useLiveTime } from './useLiveTime.js';
+import { useSelectedTime } from './useSelectedTime.js';
+
+export function createSun(map) {
+  const disc = 'position:absolute;width:18px;height:18px;border-radius:50%;transform:translate(-50%,-50%);pointer-events:none;';
+  const sunDisc = L.DomUtil.create('div', 'sunlight-sun');
+  const moonDisc = L.DomUtil.create('div', 'sunlight-moon');
+  sunDisc.style.cssText = disc + 'background:#fff3bd;box-shadow:0 0 18px 7px #ffd27699;';
+  moonDisc.style.cssText = disc + 'background:#dce5f2;box-shadow:0 0 10px 2px #cbdcff55;';
+  sunDisc.setAttribute('role', 'img'); sunDisc.setAttribute('aria-label', 'Sun');
+  moonDisc.setAttribute('role', 'img'); moonDisc.setAttribute('aria-label', 'Moon');
+  const container = L.DomUtil.create('div', 'sunlight-control');
+  container.style.cssText = 'color:#222;width:min(200px,calc(100vw - 60px));font:12px/1.4 sans-serif;';
+  const date = document.createElement('input');
+  date.type = 'date';
+  date.style.cssText = 'width:100%;box-sizing:border-box;';
+  date.setAttribute('aria-label', 'Solar date (UTC)');
+  const slider = document.createElement('input');
+  slider.type = 'range';
+  slider.style.cssText = 'width:100%;box-sizing:border-box;margin:10px 0 4px;cursor:pointer;';
+  slider.min = '0'; slider.max = '1439'; slider.step = '1';
+  slider.setAttribute('aria-label', 'Time of day (UTC)');
+  const output = document.createElement('output');
+  output.style.cssText = 'font-weight:bold;font-variant-numeric:tabular-nums;';
+  output.setAttribute('aria-live', 'off');
+  const now = document.createElement('button');
+  now.type = 'button'; now.textContent = 'Now';
+  const timeRow = document.createElement('div');
+  timeRow.className = 'sunlight-time';
+  timeRow.style.cssText = 'display:flex;justify-content:space-between;align-items:center;';
+  timeRow.append(output, now);
+  const status = document.createElement('div');
+  status.className = 'sunlight-status';
+  status.style.marginTop = '5px';
+  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,
+    projection: /* alloc */ { left: 0, top: 0 },
+  };
+  state.update = updateSun.bind(null, state);
+  state.updateSky = updateSky.bind(null, state);
+  now.onclick = useLiveTime.bind(null, state);
+  date.onchange = slider.oninput = useSelectedTime.bind(null, state);
+  L.DomEvent.disableClickPropagation(container);
+  L.DomEvent.disableScrollPropagation(container);
+  return state;
+}

package/src/sunlight/horizontalPosition.js

@@ -0,0 +1,16 @@
+import { radians } from '../globals/radians.js';
+
+export function horizontalPosition(d, lat, lng, ascension, declination) {
+  const hourAngle = (280.16 + 360.9856235 * d + lng) * radians - ascension;
+  const latitude = lat * radians;
+  const altitude = Math.asin(Math.sin(latitude) * Math.sin(declination) +
+    Math.cos(latitude) * Math.cos(declination) * Math.cos(hourAngle));
+  const southAzimuth = Math.atan2(Math.sin(hourAngle),
+    Math.cos(hourAngle) * Math.sin(latitude) - Math.tan(declination) * Math.cos(latitude));
+  const azimuth = (southAzimuth / radians + 180 + 360) % 360;
+  return /* alloc */ {
+    altitude: altitude / radians, azimuth,
+    direction: /* alloc */ [Math.sin(azimuth * radians) * Math.cos(altitude), Math.sin(altitude),
+    -Math.cos(azimuth * radians) * Math.cos(altitude)]
+  };
+}

package/src/sunlight/initSunlight.js

@@ -0,0 +1,17 @@
+import { L } from '../globals/L.js';
+import { onAddSun } from './onAddSun.js';
+import { underEntry } from '../scene/underEntry.js';
+import { initialize } from './initialize.js';
+import { onAdd } from './onAdd.js';
+import { addTo } from './addTo.js';
+import { remove } from './remove.js';
+import { onRemoveSun } from './onRemoveSun.js';
+
+L.Control.Time = L.Control.extend({
+  options: { position: 'bottomright' },
+  initialize,
+  onAdd,
+  onRemove: onRemoveSun,
+  addTo,
+  remove,
+});

package/src/sunlight/initialize.js

@@ -0,0 +1,14 @@
+import { L } from '../globals/L.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+import { addTimeLayer } from './addTimeLayer.js';
+import { removeTimeLayer } from './removeTimeLayer.js';
+
+export function initialize(options) {
+  L.Util.setOptions(this, options);
+  this.live = true;
+  this.layer = /* alloc */ new L.Layer();
+  sceneByLayer.get(this.layer).control = this;
+  sceneByLayer.get(this.layer).kind = 'time';
+}

package/src/sunlight/mix.js

@@ -0,0 +1,7 @@
+export function mix(a, b, t, values) {
+  values ||= /* alloc */ [];
+  values.length = a.length;
+  let i;
+  for (i = 0; i < a.length; i++) values[i] = a[i] + (b[i] - a[i]) * t;
+  return values;
+}

package/src/sunlight/moonPosition.js

@@ -0,0 +1,18 @@
+import { solarTime } from './solarTime.js';
+import { horizontalPosition } from "./horizontalPosition.js";
+import { radians } from '../globals/radians.js';
+import { sinObliquity } from '../globals/sinObliquity.js';
+import { cosObliquity } from '../globals/cosObliquity.js';
+
+// Low-precision geocentric lunar orbit; no parallax or atmospheric refraction.
+
+export function moonPosition(date, lat, lng) {
+  const d = solarTime(date, lat, lng) / 86400000 - 10957.5;
+  const anomaly = (134.963 + 13.064993 * d) * radians;
+  const longitude = (218.316 + 13.176396 * d + 6.289 * Math.sin(anomaly)) * radians;
+  const latitude = 5.128 * Math.sin((93.272 + 13.229350 * d) * radians) * radians;
+  const x = Math.cos(latitude) * Math.cos(longitude);
+  const y = Math.cos(latitude) * Math.sin(longitude) * cosObliquity - Math.sin(latitude) * sinObliquity;
+  const z = Math.cos(latitude) * Math.sin(longitude) * sinObliquity + Math.sin(latitude) * cosObliquity;
+  return horizontalPosition(d, lat, lng, Math.atan2(y, x), Math.asin(z));
+}

package/src/sunlight/onAdd.js

@@ -0,0 +1,5 @@
+import { onAddSun } from './onAddSun.js';
+
+export function onAdd(map) {
+  return onAddSun(this, map);
+}

package/src/sunlight/onAddSun.js

@@ -0,0 +1,27 @@
+import { cameraByMap } from '../globals/cameraByMap.js';
+import { sunlightByControl } from '../globals/sunlightByControl.js';
+import { sunByMap } from '../globals/sunByMap.js';
+import { createSun } from './createSun.js';
+import { tickSun } from './tickSun.js';
+
+export function onAddSun(control, map) {
+  let state = sunByMap.get(map);
+  if (state?.control && state.control !== control) {
+    control._map = null;
+    if (control.layer._map === map) map.removeLayer(control.layer);
+    throw /* alloc */ new Error('Only one Time control can be active per map');
+  }
+  if (!state) {
+    state = createSun(map);
+    sunByMap.set(map, state);
+  }
+  state.control = control;
+  state.originalSky = map.getContainer().style.getPropertyValue('--leaflet-sky-background');
+  cameraByMap.get(map)._timeControl = control;
+  sunlightByControl.set(control, state);
+  state.update();
+  state.timer = setInterval(tickSun, 60000, state);
+  map.on('moveend', state.update);
+  map.on('move rotate pitch resize', state.updateSky);
+  return state.container;
+}

package/src/sunlight/onRemoveSun.js

@@ -0,0 +1,10 @@
+import { sunlightByControl } from '../globals/sunlightByControl.js';
+
+import { removeSun } from './removeSun.js';
+
+export function onRemoveSun() {
+  const sunlight = sunlightByControl.get(this);
+  if (!sunlight) return;
+  removeSun(sunlight);
+  sunlightByControl.delete(this);
+}

package/src/sunlight/projectCelestialBody.js

@@ -0,0 +1,13 @@
+/** Perspective projection of a celestial direction; null when behind the camera. */
+
+export function projectCelestialBody(dir, size, pitch, bearing, target) {
+  const [x, y, z] = dir;
+  const forward = -x * Math.sin(bearing) * Math.sin(pitch) - y * Math.cos(pitch) - z * Math.cos(bearing) * Math.sin(pitch);
+  if (forward > 0) {
+    target ||= /* alloc */ {};
+    target.left = size.x / 2 + size.y * 1.5 * (x * Math.cos(bearing) - z * Math.sin(bearing)) / forward;
+    target.top = size.y / 2 - size.y * 1.5 * (-x * Math.sin(bearing) * Math.cos(pitch) + y * Math.sin(pitch) - z * Math.cos(bearing) * Math.cos(pitch)) / forward;
+    return target;
+  }
+  return null;
+}

package/src/sunlight/remove.js

@@ -0,0 +1,8 @@
+import { L } from '../globals/L.js';
+export function remove() {
+  if (this._map?.hasLayer(this.layer)) {
+    this._map.removeLayer(this.layer);
+    return this;
+  }
+  return L.Control.prototype.remove.call(this);
+}

package/src/sunlight/removeSun.js

@@ -0,0 +1,21 @@
+import { cameraByMap } from '../globals/cameraByMap.js';
+import { sunByMap } from '../globals/sunByMap.js';
+
+
+import { render } from './render.js';
+import { updateSky } from './updateSky.js';
+
+export function removeSun(state) {
+  const { map, timer, sunDisc, moonDisc } = state;
+  const shared = sunByMap.get(map);
+  clearInterval(timer);
+  delete cameraByMap.get(map)._timeControl;
+  map.fire('simulationtimechange', /* alloc */ { time: null, live: false });
+  map.off('moveend', state.update);
+  map.off('move rotate pitch resize', state.updateSky);
+  delete cameraByMap.get(map)._sunlight;
+  updateSky(state);
+  sunDisc.remove(); moonDisc.remove();
+  render(map);
+  if (shared === state) shared.control = null;
+}

package/src/sunlight/removeTimeLayer.js

@@ -0,0 +1,7 @@
+import { L } from '../globals/L.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+export function removeTimeLayer() {
+  return L.Control.prototype.remove.call(sceneByLayer.get(this).control);
+}

package/src/sunlight/render.js

@@ -0,0 +1,9 @@
+import { renderers } from '../globals/renderers.js';
+
+
+import { update as updateScene } from '../scene/update.js';
+
+export function render(map) {
+  const renderer = renderers.get(map);
+  if (renderer) updateScene(renderer);
+}

package/src/sunlight/rgb.js

@@ -0,0 +1,8 @@
+export function rgb(values) {
+  let rounded = '', i;
+  for (i = 0; i < values.length; i++) {
+    if (i) rounded += ', ';
+    rounded += Math.round(values[i]);
+  }
+  return `rgb(${rounded})`;
+}

package/src/sunlight/solarPosition.js

@@ -0,0 +1,18 @@
+import { horizontalPosition } from "./horizontalPosition.js";
+import { solarTime } from './solarTime.js';
+import { radians } from '../globals/radians.js';
+import { sinObliquity } from '../globals/sinObliquity.js';
+import { cosObliquity } from '../globals/cosObliquity.js';
+
+// Solar centre, without atmospheric refraction.
+
+export function solarPosition(date, lat, lng) {
+  const time = solarTime(date, lat, lng);
+  const d = time / 86400000 - 10957.5;
+  const mean = (357.5291 + 0.98560028 * d) * radians;
+  const longitude = mean + (1.9148 * Math.sin(mean) + 0.02 * Math.sin(2 * mean) +
+    0.0003 * Math.sin(3 * mean) + 102.9372 + 180) * radians;
+  const declination = Math.asin(Math.sin(longitude) * sinObliquity);
+  const ascension = Math.atan2(Math.sin(longitude) * cosObliquity, Math.cos(longitude));
+  return horizontalPosition(d, lat, lng, ascension, declination);
+}

package/src/sunlight/solarTime.js

@@ -0,0 +1,11 @@
+/** Normalize dates and validate the observer without calculating a celestial position. */
+export function solarTime(date, lat, lng) {
+  const time = date instanceof Date ? Date.prototype.getTime.call(date)
+    : typeof date === 'string' ? Date.parse(date)
+    : (/* alloc */ new Date(date)).getTime();
+  if (!Number.isFinite(time) || !Number.isFinite(lat) || Math.abs(lat) > 90 ||
+    !Number.isFinite(lng) || Math.abs(lng) > 180) {
+    throw /* alloc */ new Error('Invalid solar date or location');
+  }
+  return time;
+}

package/src/sunlight/styleTimeControl.js

@@ -0,0 +1,7 @@
+export function styleTimeControl(container, nested) {
+  container.classList.toggle('leaflet-control', !nested);
+  container.classList.toggle('leaflet-bar', !nested);
+  container.style.background = nested ? '' : '#fff';
+  container.style.padding = nested ? '2px 0 6px 20px' : '8px';
+  container.style.margin = nested ? '0' : '';
+}

package/src/sunlight/tickSun.js

@@ -0,0 +1,5 @@
+import { updateSun } from './updateSun.js';
+
+export function tickSun(state) {
+  if (state.control.live) updateSun(state);
+}

package/src/sunlight/updateCelestialDisc.js

@@ -0,0 +1,12 @@
+import { projectCelestialBody } from './projectCelestialBody.js';
+
+export function updateCelestialDisc(disc, body, sky, size, pitch, bearing, projection) {
+  disc.hidden = true;
+  if (!sky || !body || body.altitude <= 0) return;
+  if (disc.parentNode !== sky) sky.append(disc);
+  const point = projectCelestialBody(body.direction, size, pitch, bearing, projection);
+  if (!point) return;
+  const { left, top } = point;
+  disc.hidden = left < 0 || left > size.x || top < 0 || top > sky.clientHeight || sky.style.display === 'none';
+  disc.style.left = `${left}px`; disc.style.top = `${top}px`;
+}

package/src/sunlight/updateSky.js

@@ -0,0 +1,17 @@
+import { radians } from '../globals/radians.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+import { mapGetPitch } from '../camera/mapGetPitch.js';
+import { mapGetBearing } from '../camera/mapGetBearing.js';
+
+import { updateCelestialDisc } from './updateCelestialDisc.js';
+
+export function updateSky({ map, originalSky, sunDisc, moonDisc, projection }) {
+  const sun = cameraByMap.get(map)._sunlight, sky = cameraByMap.get(map)._pitchSky;
+  if (sun) map.getContainer().style.setProperty('--leaflet-sky-background', sun.background);
+  else if (originalSky) map.getContainer().style.setProperty('--leaflet-sky-background', originalSky);
+  else map.getContainer().style.removeProperty('--leaflet-sky-background');
+  const size = map.getSize(), pitch = mapGetPitch(map) * radians, bearing = mapGetBearing(map) * radians;
+  updateCelestialDisc(sunDisc, sun, sky, size, pitch, bearing, projection);
+  updateCelestialDisc(moonDisc, sun?.moon, sky, size, pitch, bearing, projection);
+}

package/src/sunlight/updateSun.js

@@ -0,0 +1,40 @@
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+
+import { atmosphere } from './atmosphere.js';
+import { moonPosition } from './moonPosition.js';
+import { solarPosition } from './solarPosition.js';
+import { render } from './render.js';
+import { updateSky } from './updateSky.js';
+
+export function updateSun(state) {
+  const { control, map, date, slider, output, status } = state;
+  try {
+    if (control.live) control.time = /* alloc */ new Date();
+    const time = control.time.toISOString();
+    date.value = time.slice(0, 10);
+    slider.value = String(control.time.getUTCHours() * 60 + control.time.getUTCMinutes());
+    output.textContent = `${time.slice(11, 16)} UTC${control.live ? ' · now' : ''}`;
+    const center = map.getCenter();
+    const sun = cameraByMap.get(map)._sunlight = solarPosition(control.time, center.lat, center.lng);
+    Object.assign(sun, atmosphere(sun.altitude));
+    sun.moon = moonPosition(control.time, center.lat, center.lng);
+    status.textContent = sun.altitude <= 0
+      ? 'Night · no direct sunlight'
+      : sun.altitude < 3
+        ? 'Low sun · shadows paused'
+        : `Sun altitude ${sun.altitude.toFixed(1)}°`;
+    map.fire('simulationtimechange', /* alloc */ {
+      time: /* alloc */ new Date(control.time),
+      live: control.live,
+    });
+    updateSky(state);
+    render(map);
+  } catch (error) {
+    delete cameraByMap.get(map)._sunlight;
+    updateSky(state);
+    render(map);
+    status.textContent = `Error: ${error.message}`;
+    console.error('Solar simulation', error);
+  }
+}

package/src/sunlight/useLiveTime.js

@@ -0,0 +1,6 @@
+import { updateSun } from './updateSun.js';
+
+export function useLiveTime(state) {
+  state.control.live = true;
+  updateSun(state);
+}