isard 1.1.0 → 1.3.0

package/dist/basemap/vectorstyle.js

@@ -7,42 +7,51 @@
  * interpolated in RGBA, `{token}` text fields.
  */
 import { parseCssColor } from "../util/color.js";
+import { isRecord } from "../util/guards.js";
+/** A MapLibre style, as far as the basemap reads it: its sources and its layers (an id and a type each) */
+export const isStyle = (value) => isRecord(value) &&
+    isRecord(value.sources) &&
+    Object.values(value.sources).every((s) => isRecord(s) && typeof s.type === 'string') &&
+    Array.isArray(value.layers) &&
+    value.layers.every((l) => isRecord(l) && typeof l.id === 'string' && typeof l.type === 'string');
 const TYPES = ['Unknown', 'Point', 'LineString', 'Polygon'];
-export function context(feature, zoom) {
+export const context = (feature, zoom) => {
     return { zoom, properties: feature.properties, type: TYPES[feature.type] ?? 'Unknown' };
-}
+};
 // ── Colors ──
 /** A color to RGBA 0-1, undefined if it is not one */
-export function color(value) {
+export const color = (value) => {
     return parseCssColor(value);
-}
-export function css([r, g, b, a]) {
+};
+export const css = ([r, g, b, a]) => {
     return `rgba(${Math.round(r * 255)},${Math.round(g * 255)},${Math.round(b * 255)},${a})`;
-}
+};
 // ── Interpolation ──
 /** Factor between two stops: linear, or exponential of `base` */
-function factor(x, x0, x1, base = 1) {
+const factor = (x, x0, x1, base = 1) => {
     const d = x1 - x0;
     if (d === 0)
         return 0;
     const t = x - x0;
     return base === 1 ? t / d : (base ** t - 1) / (base ** d - 1);
-}
-function mix(a, b, t) {
+};
+const mix = (a, b, t) => {
     if (typeof a === 'number' && typeof b === 'number')
         return a + (b - a) * t;
     const ca = color(a);
     const cb = color(b);
-    if (ca && cb)
-        return css([0, 1, 2, 3].map((i) => (ca[i] ?? 0) + ((cb[i] ?? 0) - (ca[i] ?? 0)) * t));
+    if (ca && cb) {
+        const lerp = (i) => ca[i] + (cb[i] - ca[i]) * t;
+        return css([lerp(0), lerp(1), lerp(2), lerp(3)]);
+    }
     if (Array.isArray(a) && Array.isArray(b))
         return a.map((v, i) => mix(v, b[i], t));
     return t < 0.5 ? a : b;
-}
-function isFunction(v) {
+};
+const isFunction = (v) => {
     return typeof v === 'object' && v !== null && !Array.isArray(v) && Array.isArray(v.stops);
-}
-function legacy(f, ctx) {
+};
+const legacy = (f, ctx) => {
     const input = f.property === undefined ? ctx.zoom : ctx.properties[f.property];
     const stops = f.stops;
     const type = f.type ?? (f.property === undefined || typeof stops[0]?.[0] === 'number' ? 'exponential' : 'categorical');
@@ -53,30 +62,45 @@ function legacy(f, ctx) {
     if (typeof input !== 'number' || !stops.length)
         return f.default ?? stops[0]?.[1];
     // Zoom-and-property stops ({ zoom, value } keys) are taken at their zoom only
-    const key = (s) => typeof s[0] === 'object' && s[0] !== null ? Number(s[0].zoom) : Number(s[0]);
+    const key = ([k]) => {
+        if (Array.isArray(k))
+            return Number.NaN;
+        return isRecord(k) ? Number(k.zoom) : Number(k);
+    };
     const first = stops[0];
     if (!first)
         return f.default;
     if (input <= key(first))
         return first[1];
-    for (let i = 1; i < stops.length; i += 1) {
-        const [s0, s1] = [stops[i - 1], stops[i]];
-        if (!s0 || !s1)
-            continue;
-        if (input < key(s1)) {
-            if (type === 'interval')
-                return s0[1];
-            return mix(s0[1], s1[1], factor(input, key(s0), key(s1), f.base ?? 1));
-        }
-    }
-    return stops.at(-1)?.[1];
-}
+    const at = stops.findIndex((s1, i) => i > 0 && Boolean(stops[i - 1]) && Boolean(s1) && input < key(s1));
+    const [s0, s1] = [stops[at - 1], stops[at]];
+    if (at < 0 || !s0 || !s1)
+        return stops.at(-1)?.[1];
+    if (type === 'interval')
+        return s0[1];
+    return mix(s0[1], s1[1], factor(input, key(s0), key(s1), f.base ?? 1));
+};
 // ── Expressions ──
-function get(ctx, key) {
+/** A list of values to look a value up in (any value: `includes` compares with `===`) */
+const labels = (values) => values;
+const ORDERS = {
+    '<': (a, b) => a < b,
+    '<=': (a, b) => a <= b,
+    '>': (a, b) => a > b,
+    '>=': (a, b) => a >= b,
+};
+/** A comparison of any two values the way JavaScript's operators make it: two strings (lists and objects as their
+ * text) in text order, anything else as numbers */
+const compare = (op, a, b) => {
+    const text = (v) => (typeof v === 'object' && v !== null ? String(v) : v);
+    const [x, y] = [text(a), text(b)];
+    return typeof x === 'string' && typeof y === 'string' ? ORDERS[op](x, y) : ORDERS[op](Number(x), Number(y));
+};
+const get = (ctx, key) => {
     if (key === '$type')
         return ctx.type;
     return typeof key === 'string' ? ctx.properties[key] : undefined;
-}
+};
 /** The operators `evaluate` knows */
 const OPERATORS = new Set([
     'literal',
@@ -142,13 +166,13 @@ const OPERATORS = new Set([
     'e',
 ]);
 /** Whether a value is an expression (an array starting with a known operator), not a literal array */
-export function isExpression(e) {
+export const isExpression = (e) => {
     return Array.isArray(e) && typeof e[0] === 'string' && OPERATORS.has(e[0]);
-}
+};
 /** Operators already warned about */
 const warned = new Set();
 const str = (v) => (v === undefined || v === null ? '' : String(v));
-export function evaluate(e, ctx) {
+export const evaluate = (e, ctx) => {
     if (isFunction(e))
         return legacy(e, ctx);
     if (!Array.isArray(e))
@@ -184,13 +208,17 @@ export function evaluate(e, ctx) {
         case 'image':
             return ev(0);
         case 'number-format': {
-            const options = (args[1] ?? {});
+            const options = isRecord(args[1]) ? args[1] : {};
+            const option = (key) => {
+                const v = options[key];
+                return typeof v === 'number' ? v : undefined;
+            };
             const n = num(0);
             if (!Number.isFinite(n))
                 return '';
-            return n.toLocaleString(options.locale, {
-                minimumFractionDigits: options['min-fraction-digits'],
-                maximumFractionDigits: options['max-fraction-digits'],
+            return n.toLocaleString(typeof options.locale === 'string' ? options.locale : undefined, {
+                minimumFractionDigits: option('min-fraction-digits'),
+                maximumFractionDigits: option('max-fraction-digits'),
             });
         }
         case 'to-number': {
@@ -262,13 +290,10 @@ export function evaluate(e, ctx) {
         case '!=':
             return ev(0) !== ev(1);
         case '<':
-            return ev(0) < ev(1);
         case '<=':
-            return ev(0) <= ev(1);
         case '>':
-            return ev(0) > ev(1);
         case '>=':
-            return ev(0) >= ev(1);
+            return compare(op, ev(0), ev(1));
         case 'in': {
             const haystack = ev(1);
             const needle = ev(0);
@@ -277,19 +302,15 @@ export function evaluate(e, ctx) {
             return Array.isArray(haystack) && haystack.includes(needle);
         }
         case 'case': {
-            for (let i = 0; i + 1 < args.length; i += 2)
-                if (ev(i))
-                    return ev(i + 1);
-            return ev(args.length - 1);
+            const hit = args.findIndex((_, i) => i % 2 === 0 && i + 1 < args.length && Boolean(ev(i)));
+            return hit < 0 ? ev(args.length - 1) : ev(hit + 1);
         }
         case 'match': {
             const input = ev(0);
-            for (let i = 1; i + 1 < args.length; i += 2) {
-                const label = args[i];
-                if (Array.isArray(label) ? label.includes(input) : label === input)
-                    return ev(i + 1);
-            }
-            return ev(args.length - 1);
+            const hit = args.findIndex((label, i) => i % 2 === 1 &&
+                i + 1 < args.length &&
+                (Array.isArray(label) ? labels(label).includes(input) : label === input));
+            return hit < 0 ? ev(args.length - 1) : ev(hit + 1);
         }
         case 'step': {
             const input = num(0);
@@ -308,20 +329,20 @@ export function evaluate(e, ctx) {
             const kind = args[0];
             const input = num(1);
             const base = Array.isArray(kind) && kind[0] === 'exponential' ? Number(kind[1]) : 1;
-            const stops = [];
-            for (let i = 2; i + 1 < args.length; i += 2)
-                stops.push([Number(args[i]), args[i + 1] ?? null]);
+            const stops = Array.from({ length: Math.floor((args.length - 2) / 2) }, (_, k) => [
+                Number(args[2 + 2 * k]),
+                args[3 + 2 * k] ?? null,
+            ]);
             const first = stops[0];
             if (!first)
                 return null;
             if (input <= first[0])
                 return evaluate(first[1], ctx);
-            for (let i = 1; i < stops.length; i += 1) {
-                const [s0, s1] = [stops[i - 1], stops[i]];
-                if (s0 && s1 && input < s1[0])
-                    return mix(evaluate(s0[1], ctx), evaluate(s1[1], ctx), factor(input, s0[0], s1[0], base));
-            }
-            return evaluate(stops.at(-1)?.[1] ?? null, ctx);
+            const at = stops.findIndex((s1, i) => i > 0 && input < s1[0]);
+            const [s0, s1] = [stops[at - 1], stops[at]];
+            if (at < 0 || !s0 || !s1)
+                return evaluate(stops.at(-1)?.[1] ?? null, ctx);
+            return mix(evaluate(s0[1], ctx), evaluate(s1[1], ctx), factor(input, s0[0], s1[0], base));
         }
         case 'rgb':
         case 'rgba':
@@ -371,12 +392,26 @@ export function evaluate(e, ctx) {
             }
             return null;
     }
-}
+};
 // ── Filters ──
 const LEGACY_COMPARISONS = new Set(['==', '!=', '<', '<=', '>', '>=']);
+/** The kind of geometry a style layer is drawn with as vectors (`vectors()`: backgrounds as fills, extrusions raised
+ * into blocks); undefined for the others (symbols, circles, rasters) and for the layers drawn with a pattern (their
+ * images are the raster path's) */
+export const vectorKind = (layer) => {
+    const paint = layer.paint ?? {};
+    if (['fill-pattern', 'line-pattern', 'fill-extrusion-pattern', 'background-pattern'].some((k) => k in paint)) {
+        return undefined;
+    }
+    if (layer.type === 'line')
+        return 'line';
+    if (layer.type === 'fill-extrusion')
+        return 'extrusion';
+    return layer.type === 'fill' || layer.type === 'background' ? 'fill' : undefined;
+};
 /** Whether a filter (not `all`, `any`, `none`) is in the legacy form: `["==", "key", value]`, `["in", "key", a, b]`,
  * `["has", "key"]`; a key and literal values, as MapLibre tells them from expressions */
-function isLegacyLeaf(f) {
+const isLegacyLeaf = (f) => {
     const [op, a, ...rest] = f;
     if (typeof op !== 'string' || typeof a !== 'string' || rest.some(Array.isArray))
         return false;
@@ -385,8 +420,8 @@ function isLegacyLeaf(f) {
     if (op === 'in')
         return f.length !== 3 || !Array.isArray(f[2]);
     return op === '!in' || op === 'has' || op === '!has';
-}
-function legacyFilter(f, ctx) {
+};
+const legacyFilter = (f, ctx) => {
     const [op, key, ...rest] = f;
     const v = get(ctx, key);
     switch (op) {
@@ -395,17 +430,14 @@ function legacyFilter(f, ctx) {
         case '!=':
             return v !== rest[0];
         case '<':
-            return v < rest[0];
         case '<=':
-            return v <= rest[0];
         case '>':
-            return v > rest[0];
         case '>=':
-            return v >= rest[0];
+            return compare(op, v, rest[0]);
         case 'in':
-            return rest.includes(v);
+            return labels(rest).includes(v);
         case '!in':
-            return !rest.includes(v);
+            return !labels(rest).includes(v);
         case 'has':
             return v !== undefined;
         case '!has':
@@ -413,53 +445,53 @@ function legacyFilter(f, ctx) {
         default:
             return true;
     }
-}
+};
 /** Compiled filters, by filter object */
 const compiled = new WeakMap();
 /** A filter as a function: `all`, `any`, `none` of their parts, each part legacy or an expression (they may mix) */
-function compile(f) {
+const compile = (f) => {
     if (!Array.isArray(f))
         return () => Boolean(f);
     const hit = compiled.get(f);
     if (hit)
         return hit;
-    let test;
-    const op = f[0];
-    if (op === 'all' || op === 'any' || op === 'none') {
-        const parts = f.slice(1).map(compile);
-        if (op === 'all')
-            test = (ctx) => parts.every((p) => p(ctx));
-        else if (op === 'any')
-            test = (ctx) => parts.some((p) => p(ctx));
-        else
-            test = (ctx) => !parts.some((p) => p(ctx));
-    }
-    else if (isLegacyLeaf(f)) {
-        test = (ctx) => legacyFilter(f, ctx);
-    }
-    else {
-        test = (ctx) => Boolean(evaluate(f, ctx));
-    }
+    const make = () => {
+        const op = f[0];
+        if (op === 'all' || op === 'any' || op === 'none') {
+            const parts = f.slice(1).map(compile);
+            if (op === 'all')
+                return (ctx) => parts.every((p) => p(ctx));
+            if (op === 'any')
+                return (ctx) => parts.some((p) => p(ctx));
+            return (ctx) => !parts.some((p) => p(ctx));
+        }
+        if (isLegacyLeaf(f))
+            return (ctx) => legacyFilter(f, ctx);
+        return (ctx) => Boolean(evaluate(f, ctx));
+    };
+    const test = make();
     compiled.set(f, test);
     return test;
-}
-export function filter(f, ctx) {
+};
+export const filter = (f, ctx) => {
     if (f === undefined || f === null)
         return true;
     return compile(f)(ctx);
-}
+};
+/** The operators that read the feature */
+const FEATURE_OPERATORS = new Set(['get', 'has', '!has', 'geometry-type', 'properties', 'id']);
 /** Whether a value depends on the feature (else only on the zoom, evaluated once per tile) */
-export function isFeatureDependent(e) {
+export const isFeatureDependent = (e) => {
     if (e !== undefined && isFunction(e))
         return e.property !== undefined;
     if (!Array.isArray(e))
         return false;
-    if (['get', 'has', '!has', 'geometry-type', 'properties', 'id'].includes(e[0]))
+    if (FEATURE_OPERATORS.has(e[0]))
         return true;
     return e.some((x) => isFeatureDependent(x));
-}
+};
 /** A `{token}` text field (or an expression) to the text of a feature */
-export function text(field, ctx) {
+export const text = (field, ctx) => {
     if (field === undefined || field === null)
         return '';
     if (typeof field === 'string') {
@@ -474,45 +506,66 @@ export function text(field, ctx) {
         return v.filter((x) => typeof x === 'string').join('');
     }
     return v === undefined || v === null ? '' : String(v);
-}
+};
 /** The font of a label from the first of its `text-font`: a family without its weight takes the regular one */
-export function labelFont(font) {
+export const labelFont = (font) => {
     return /Regular|Bold|Italic|Semibold|Light|Medium|Black/.test(font) ? font : `${font} Regular`;
-}
+};
 /**
  * A value of the zoom only (an expression: `interpolate`, `step` of `["zoom"]`) as stops `[[zoom, value], …]` for the
  * engine, which interpolates them linearly: evaluated at its own stops and at the whole zooms between (an exponential
  * curve followed closely), a step kept sharp just before its threshold
  */
-export function zoomStops(e) {
+export const zoomStops = (e) => {
     const zooms = new Set();
+    // The inputs of the stops of an `interpolate` or a `step` (from its fourth argument, one in two)
+    const stopInputs = (x) => x.filter((_, i) => i >= 3 && i % 2 === 1).map(Number);
     const walk = (x) => {
         if (!Array.isArray(x))
             return;
         const zoomInput = (input) => Array.isArray(input) && input[0] === 'zoom';
         if ((x[0] === 'interpolate' || x[0] === 'interpolate-hcl' || x[0] === 'interpolate-lab') && zoomInput(x[2])) {
-            for (let i = 3; i < x.length; i += 2)
-                zooms.add(Number(x[i]));
+            stopInputs(x).forEach((t) => {
+                zooms.add(t);
+            });
         }
         else if (x[0] === 'step' && zoomInput(x[1])) {
-            for (let i = 3; i < x.length; i += 2) {
-                const t = Number(x[i]);
+            stopInputs(x).forEach((t) => {
                 zooms.add(t);
                 zooms.add(t - 0.01);
-            }
+            });
         }
-        for (const y of x)
-            walk(y);
+        x.forEach(walk);
     };
     walk(e);
     const finite = [...zooms].filter(Number.isFinite);
     if (finite.length === 0)
         finite.push(0);
     const [lo, hi] = [Math.min(...finite), Math.max(...finite)];
-    for (let z = Math.ceil(lo); z <= Math.floor(hi); z += 1)
-        finite.push(z);
+    finite.push(...Array.from({ length: Math.floor(hi) - Math.ceil(lo) + 1 }, (_, i) => Math.ceil(lo) + i));
     return [...new Set(finite)]
         .sort((a, b) => a - b)
         .map((zoom) => [zoom, Number(evaluate(e, { zoom, properties: {}, type: 'Unknown' }))]);
-}
+};
+/**
+ * A paint value as zoom stops when it depends on the zoom only (an expression as `zoomStops` samples it, a legacy zoom
+ * function at its stops and the whole zooms between), a number as it is, `fallback` when missing; undefined when it
+ * depends on the features
+ */
+export const zoomOnly = (v, fallback) => {
+    if (v === undefined || v === null)
+        return fallback;
+    if (isFeatureDependent(v))
+        return undefined;
+    if (isExpression(v))
+        return zoomStops(v);
+    if (!isFunction(v))
+        return Number(v);
+    const zooms = v.stops.map(([z]) => Number(z)).filter(Number.isFinite);
+    const [lo, hi] = [Math.min(...zooms), Math.max(...zooms)];
+    const whole = Array.from({ length: Math.max(0, Math.floor(hi) - Math.ceil(lo) + 1) }, (_, i) => Math.ceil(lo) + i);
+    return [...new Set([...zooms, ...whole])]
+        .sort((a, b) => a - b)
+        .map((zoom) => [zoom, Number(evaluate(v, { zoom, properties: {}, type: 'Unknown' }))]);
+};
 //# sourceMappingURL=vectorstyle.js.map