isard 1.1.0 → 1.2.0

package/dist/workers/basemap.worker.js

@@ -17,14 +17,11 @@ import { setHeaderRules, withHeaders } from "../engine/requests.js";
 import { latitude, longitude } from "../util/geo.js";
 import { Lru } from "../util/lru.js";
 /** An image of the sprites and its sheet */
-function spriteIcon(r, name) {
-    for (const sprite of r.sprites) {
-        const icon = sprite.icons[name];
-        if (icon)
-            return { icon, image: sprite.image };
-    }
-    return undefined;
-}
+const spriteIcon = (r, name) => {
+    const sprite = r.sprites.find((sp) => Boolean(sp.icons[name]));
+    const icon = sprite?.icons[name];
+    return sprite && icon ? { icon, image: sprite.image } : undefined;
+};
 const renderers = new Map();
 /** Decoded tiles kept by the pool, shared among its workers (a vector tile always goes to the same worker): some
  * 2 MB each */
@@ -32,9 +29,9 @@ const CACHE = 96;
 /** Decoded tiles by URL; this worker's share of them, set by the renderers */
 const cache = new Lru(CACHE);
 /** The decoded tiles one worker of `workers` keeps */
-export function cacheShare(workers) {
+export const cacheShare = (workers) => {
     return Math.max(16, Math.ceil(CACHE / Math.max(1, workers)));
-}
+};
 /** Requests in progress, and those of them aborted (both forgotten once answered) */
 const active = new Set();
 const aborted = new Set();
@@ -48,7 +45,7 @@ const reprojection = resampler();
  * drawn it (they draw without awaiting again) */
 const images = new Lru(64, (evicted) => evicted.then((bitmap) => setTimeout(() => bitmap?.close(), 0), () => undefined));
 /** An image of a raster source (shared by every renderer); undefined where the source has none */
-function image(url, priority = 'auto') {
+const image = (url, priority = 'auto') => {
     const hit = images.get(url);
     if (hit)
         return hit;
@@ -70,9 +67,9 @@ function image(url, priority = 'auto') {
     pending.catch(() => images.delete(url));
     images.set(url, pending);
     return pending;
-}
+};
 /** A vector tile, decoded (shared by every renderer of its URL); the first request's priority fetches it */
-function tile(url, priority = 'auto') {
+const tile = (url, priority = 'auto') => {
     const hit = cache.get(url);
     if (hit)
         return hit;
@@ -100,9 +97,9 @@ function tile(url, priority = 'auto') {
     pending.catch(() => cache.delete(url));
     cache.set(url, pending);
     return pending;
-}
+};
 /** The vector tile to draw a raster tile from, and where the raster tile lies in it (tile units) */
-function source(r, z, x, y) {
+const source = (r, z, x, y) => {
     const vz = Math.max(0, Math.min(z - 1, r.maxzoom));
     const d = z - vz;
     const n = 2 ** Math.max(0, d);
@@ -111,7 +108,7 @@ function source(r, z, x, y) {
     // Fraction of the vector tile covered, and the offset in it
     const part = 1 / n;
     return { url, vz, vx, vy, part, ox: (x % n) * part, oy: (y % n) * part };
-}
+};
 const value = (layer, group, key, ctx, fallback) => {
     const v = layer[group]?.[key];
     if (v === undefined)
@@ -121,35 +118,46 @@ const value = (layer, group, key, ctx, fallback) => {
     return out === undefined || out === null ? fallback : out;
 };
 /** A color with an opacity, for the canvas */
-function paint(c, opacity) {
+const paint = (c, opacity) => {
     const rgba = color(c) ?? [0, 0, 0, 1];
     return css([rgba[0], rgba[1], rgba[2], rgba[3] * opacity]);
-}
-function shown(layer, zoom) {
+};
+const shown = (layer, zoom) => {
     if (layer.layout?.visibility === 'none')
         return false;
     return zoom >= (layer.minzoom ?? 0) && zoom < (layer.maxzoom ?? 24);
-}
+};
+const LINE_CAPS = new Set(['butt', 'round', 'square']);
+const LINE_JOINS = new Set(['bevel', 'miter', 'round']);
+const isLineCap = (value) => LINE_CAPS.has(value);
+const isLineJoin = (value) => LINE_JOINS.has(value);
+/** A style's `line-cap` for the canvas: `butt` if it is none */
+const lineCap = (value) => (isLineCap(value) ? value : 'butt');
+/** A style's `line-join` for the canvas: `miter` if it is none */
+const lineJoin = (value) => (isLineJoin(value) ? value : 'miter');
 /** The image of a fill pattern, cut from the sprite on first use */
-function patternImage(r, name) {
+const patternImage = (r, name) => {
     if (r.patterns.has(name))
         return r.patterns.get(name);
-    const found = spriteIcon(r, name);
-    let image;
-    if (found && found.icon.width > 0 && found.icon.height > 0) {
+    const cut = () => {
+        const found = spriteIcon(r, name);
+        if (!found || !(found.icon.width > 0) || !(found.icon.height > 0))
+            return undefined;
         const { icon } = found;
-        image = new OffscreenCanvas(icon.width, icon.height);
-        image
+        const canvas = new OffscreenCanvas(icon.width, icon.height);
+        canvas
             .getContext('2d')
             ?.drawImage(found.image, icon.x, icon.y, icon.width, icon.height, 0, 0, icon.width, icon.height);
-    }
+        return canvas;
+    };
+    const image = cut();
     r.patterns.set(name, image);
     return image;
-}
+};
 /** Canvases free for the next tiles, by size: one per tile being drawn at most */
 const canvases = new Map();
 /** A blank canvas of `size` pixels and its context, from the free ones if any */
-function takeCanvas(size) {
+const takeCanvas = (size) => {
     const canvas = canvases.get(size)?.pop() ?? new OffscreenCanvas(size, size);
     // A canvas on the CPU: its pixels are read back here, in the worker, not on the main thread at the upload
     const g = canvas.getContext('2d', { willReadFrequently: true });
@@ -161,24 +169,24 @@ function takeCanvas(size) {
     g.setLineDash([]);
     g.clearRect(0, 0, size, size);
     return { canvas, g };
-}
-function giveCanvas(canvas) {
+};
+const giveCanvas = (canvas) => {
     const free = canvases.get(canvas.width) ?? [];
     canvases.set(canvas.width, free);
     if (free.length < 4)
         free.push(canvas);
-}
+};
 /**
  * The image of a drawn canvas, its alpha straight (the engine blends straight alpha). An opaque tile (a background
  * of full opacity, as a basemap's) is moved out of the canvas as it is, premultiplied and straight being the same
  * there; another one is read back unpremultiplied, copied
  */
-export function tileImage(canvas, g, opaque) {
+export const tileImage = (canvas, g, opaque) => {
     if (opaque)
         return Promise.resolve(canvas.transferToImageBitmap());
     return createImageBitmap(g.getImageData(0, 0, canvas.width, canvas.height), { premultiplyAlpha: 'none' });
-}
-async function render(r, z, x, y, size, id, priority) {
+};
+const render = async (r, z, x, y, size, id, priority) => {
     const s = source(r, z, x, y);
     const layers = await tile(s.url, priority);
     if (aborted.has(id))
@@ -190,8 +198,8 @@ async function render(r, z, x, y, size, id, priority) {
     finally {
         giveCanvas(canvas);
     }
-}
-async function draw(r, s, layers, canvas, g, z, x, y, size, id, priority) {
+};
+const draw = async (r, s, layers, canvas, g, z, x, y, size, id, priority) => {
     const zoom = Math.max(0, z - 1);
     // CSS pixels to canvas pixels: the tile is 256 CSS pixels across at its zoom
     const px = size / 256;
@@ -258,11 +266,10 @@ async function draw(r, s, layers, canvas, g, z, x, y, size, id, priority) {
         // Values that only depend on the zoom are evaluated once for the layer
         const dependent = new Map();
         const get = (group, key, ctx, fallback) => {
-            let d = dependent.get(key);
-            if (d === undefined) {
-                d = isFeatureDependent(layer[group]?.[key]);
+            const known = dependent.get(key);
+            const d = known ?? isFeatureDependent(layer[group]?.[key]);
+            if (known === undefined)
                 dependent.set(key, d);
-            }
             return value(layer, group, key, d ? ctx : zctx, fallback);
         };
         for (const f of data.features) {
@@ -281,7 +288,7 @@ async function draw(r, s, layers, canvas, g, z, x, y, size, id, priority) {
                 const pattern = get('paint', 'fill-pattern', ctx, undefined);
                 path(f, true);
                 const icon = typeof pattern === 'string' ? spriteIcon(r, pattern)?.icon : undefined;
-                const image = icon && patternImage(r, pattern);
+                const image = icon && typeof pattern === 'string' && patternImage(r, pattern);
                 if (icon && image) {
                     const p = g.createPattern(image, 'repeat');
                     if (p) {
@@ -313,8 +320,8 @@ async function draw(r, s, layers, canvas, g, z, x, y, size, id, priority) {
                 const gap = Number(get('paint', 'line-gap-width', ctx, 0));
                 g.strokeStyle = paint(get('paint', 'line-color', ctx, '#000'), Number(get('paint', 'line-opacity', ctx, 1)));
                 g.lineWidth = (gap > 0 ? gap + 2 * width : width) * px;
-                g.lineCap = String(get('layout', 'line-cap', ctx, 'butt'));
-                g.lineJoin = String(get('layout', 'line-join', ctx, 'miter'));
+                g.lineCap = lineCap(get('layout', 'line-cap', ctx, 'butt'));
+                g.lineJoin = lineJoin(get('layout', 'line-join', ctx, 'miter'));
                 const dash = get('paint', 'line-dasharray', ctx, undefined);
                 g.setLineDash(Array.isArray(dash) ? dash.map((d) => Number(d) * width * px) : []);
                 path(f, f.type === 3);
@@ -343,9 +350,9 @@ async function draw(r, s, layers, canvas, g, z, x, y, size, id, priority) {
     if (!drawn && !layers)
         return null;
     return tileImage(canvas, g, opaque);
-}
+};
 /** How a layer's text or icon (`prefix`) meets the others: allowed to overlap, ignored by the placement */
-function overlapOf(layer, prefix, ctx) {
+const overlapOf = (layer, prefix, ctx) => {
     const allow = Boolean(value(layer, 'layout', `${prefix}-allow-overlap`, ctx, false));
     const ignore = Boolean(value(layer, 'layout', `${prefix}-ignore-placement`, ctx, false));
     if (allow && ignore)
@@ -353,20 +360,28 @@ function overlapOf(layer, prefix, ctx) {
     if (allow)
         return 'allow';
     return ignore ? 'ignore' : false;
-}
+};
 /** A pair of numbers of a style value, `fallback` if it is not one */
-function pair(v, fallback) {
+const pair = (v, fallback) => {
     return Array.isArray(v) ? [Number(v[0] ?? fallback[0]), Number(v[1] ?? fallback[1])] : fallback;
-}
+};
 /** Top, right, bottom, left of one to four numbers, as CSS's sides */
-function sides(v) {
+const sides = (v) => {
     const n = (Array.isArray(v) ? v : [v]).map((x) => Number(x) || 0);
     const [top = 0, right = top, bottom = top, left = right] = n;
     return [top, right, bottom, left];
-}
+};
+/** A label's text in the case of its `text-transform` */
+const cased = (t, transform) => {
+    if (transform === 'uppercase')
+        return t.toUpperCase();
+    if (transform === 'lowercase')
+        return t.toLowerCase();
+    return t;
+};
 /** Points every `spacing` along a line (tile units, x and y interleaved), the first half a spacing in (the middle of a
  * shorter line): each point and the segment it lies on (x, y, x0, y0, x1, y1) */
-export function lineAnchors(line, spacing) {
+export const lineAnchors = (line, spacing) => {
     let length = 0;
     for (let i = 2; i + 1 < line.length; i += 2) {
         length += Math.hypot((line[i] ?? 0) - (line[i - 2] ?? 0), (line[i + 1] ?? 0) - (line[i - 1] ?? 0));
@@ -387,14 +402,14 @@ export function lineAnchors(line, spacing) {
         walked += d;
     }
     return out;
-}
+};
 /** Longitude and latitude of a point of tile (z, x, y) in tile units */
-function lonLat(z, x, y, extent, px, py) {
+const lonLat = (z, x, y, extent, px, py) => {
     const n = 2 ** z;
     return [longitude((x + px / extent) / n), latitude((y + py / extent) / n)];
-}
+};
 /** The icon of a label: its layer's icon properties for the feature */
-function iconOf(layer, image, ctx, placement, sizeOf) {
+const iconOf = (layer, image, ctx, placement, sizeOf) => {
     const alignment = value(layer, 'layout', 'icon-rotation-alignment', ctx, 'auto');
     const fit = String(value(layer, 'layout', 'icon-text-fit', ctx, 'none'));
     const padding = value(layer, 'layout', 'icon-text-fit-padding', ctx, [0, 0, 0, 0]);
@@ -414,8 +429,8 @@ function iconOf(layer, image, ctx, placement, sizeOf) {
         color: String(value(layer, 'paint', 'icon-color', ctx, '#000')),
         opacity: Number(value(layer, 'paint', 'icon-opacity', ctx, 1)),
     };
-}
-async function labels(r, z, x, y, id, priority, zoom = z) {
+};
+const labels = async (r, z, x, y, id, priority, zoom = z) => {
     const url = r.tiles.replace('{z}', String(z)).replace('{x}', String(x)).replace('{y}', String(y));
     const layers = await tile(url, priority);
     if (!layers || aborted.has(id))
@@ -424,23 +439,23 @@ async function labels(r, z, x, y, id, priority, zoom = z) {
     // The text size of a layer when it depends on the zoom only: legacy stops as they are, an expression as stops
     const sizes = new Map();
     const sizeOf = (layer) => {
-        let s = sizes.get(layer);
-        if (s === undefined) {
-            const v = layer.layout?.['text-size'] ?? 16;
-            s = isExpression(v) ? zoomStops(v) : v;
-            sizes.set(layer, s);
-        }
+        const known = sizes.get(layer);
+        if (known !== undefined)
+            return known;
+        const v = layer.layout?.['text-size'] ?? 16;
+        const s = isExpression(v) ? zoomStops(v) : v;
+        sizes.set(layer, s);
         return s;
     };
     // The icon size of a layer when it depends on the zoom only, as the text size
     const iconSizes = new Map();
     const iconSizeOf = (layer) => {
-        let s = iconSizes.get(layer);
-        if (s === undefined) {
-            const v = layer.layout?.['icon-size'] ?? 1;
-            s = isExpression(v) ? zoomStops(v) : v;
-            iconSizes.set(layer, s);
-        }
+        const known = iconSizes.get(layer);
+        if (known !== undefined)
+            return known;
+        const v = layer.layout?.['icon-size'] ?? 1;
+        const s = isExpression(v) ? zoomStops(v) : v;
+        iconSizes.set(layer, s);
         return s;
     };
     r.layers.forEach((layer, index) => {
@@ -459,18 +474,13 @@ async function labels(r, z, x, y, id, priority, zoom = z) {
             const ctx = context(f, zoom);
             if (!filter(layer.filter, ctx))
                 continue;
-            let t = text(layout['text-field'], ctx).trim();
+            const field = text(layout['text-field'], ctx).trim();
             const image = text(layout['icon-image'], ctx).trim();
-            if (!t && !image)
+            if (!field && !image)
                 continue;
-            const transform = value(layer, 'layout', 'text-transform', ctx, 'none');
-            if (transform === 'uppercase')
-                t = t.toUpperCase();
-            else if (transform === 'lowercase')
-                t = t.toLowerCase();
+            const t = cased(field, value(layer, 'layout', 'text-transform', ctx, 'none'));
             const fonts = value(layer, 'layout', 'text-font', ctx, ['Noto Sans Regular']);
             const font = labelFont(Array.isArray(fonts) && typeof fonts[0] === 'string' ? fonts[0] : 'Noto Sans Regular');
-            const offset = value(layer, 'layout', 'text-offset', ctx, [0, 0]);
             const base = {
                 layer: index,
                 text: t,
@@ -483,7 +493,7 @@ async function labels(r, z, x, y, id, priority, zoom = z) {
                 haloColor: String(value(layer, 'paint', 'text-halo-color', ctx, 'rgba(0,0,0,0)')),
                 haloWidth: Number(value(layer, 'paint', 'text-halo-width', ctx, 0)),
                 anchor: String(value(layer, 'layout', 'text-anchor', ctx, 'center')),
-                offset: (Array.isArray(offset) ? [Number(offset[0] ?? 0), Number(offset[1] ?? 0)] : [0, 0]),
+                offset: pair(value(layer, 'layout', 'text-offset', ctx, [0, 0]), [0, 0]),
                 maxWidth: Number(value(layer, 'layout', 'text-max-width', ctx, 10)),
                 lineHeight: Number(value(layer, 'layout', 'text-line-height', ctx, 1.2)),
                 overlap: overlapOf(layer, 'text', ctx),
@@ -554,7 +564,7 @@ async function labels(r, z, x, y, id, priority, zoom = z) {
         }
     });
     return out;
-}
+};
 const post = (message, transfer = []) => self.postMessage(message, transfer);
 self.onmessage = async ({ data }) => {
     if (data.type === 'headers') {
@@ -576,8 +586,9 @@ self.onmessage = async ({ data }) => {
     }
     if (data.type === 'drop') {
         // Its copy of the sprites
-        for (const sprite of renderers.get(data.key)?.sprites ?? [])
+        renderers.get(data.key)?.sprites.forEach((sprite) => {
             sprite.image.close();
+        });
         renderers.delete(data.key);
         return;
     }
@@ -617,7 +628,7 @@ self.onmessage = async ({ data }) => {
     }
 };
 /** A tile of another layer: the altitudes of a relief tile, or a reprojected raster tile */
-async function decodeTile(data) {
+const decodeTile = async (data) => {
     const controller = new AbortController();
     controllers.set(data.id, controller);
     try {
@@ -643,5 +654,5 @@ async function decodeTile(data) {
     finally {
         controllers.delete(data.id);
     }
-}
+};
 //# sourceMappingURL=basemap.worker.js.map