From ba0fad3c35353b1ba8210eb6810198e87870645b Mon Sep 17 00:00:00 2001 From: Sameh Khamis Date: Wed, 11 Nov 2026 20:22:44 -0800 Subject: [PATCH] vectorBase: a value of the wrong kind is the property's default A colour the canvas cannot read, a keyword its property does not take, or a number given as a string was handed to the canvas, which ignored it and drew the last feature's style. Colours now go through parseColor (which now knows every CSS colour name), keywords are checked against their property's values, and only finite numbers are numbers; anything else is the property's default, as MapLibre coerces it. The style's background is read the same way, so a value it cannot use is black at opacity 1 rather than no background. --- docs/RENDERER-CONTRACT.md | 6 +- src/render/vectorBase/expressions.js | 67 +++++++++++++++---- src/render/vectorBase/paint.js | 71 ++++++++++++-------- src/render/vectorBase/style.js | 36 ++++------- src/render/vectorBase/vectorBase.test.mjs | 79 +++++++++++++++++++++++ 5 files changed, 192 insertions(+), 67 deletions(-) diff --git a/docs/RENDERER-CONTRACT.md b/docs/RENDERER-CONTRACT.md index 6aea35878..305f65dfb 100644 --- a/docs/RENDERER-CONTRACT.md +++ b/docs/RENDERER-CONTRACT.md @@ -347,8 +347,10 @@ What it draws of the style specification: `line-gradient` or a translation; layers whose values use an expression not listed (or are malformed). As MapLibre does, a paint or layout value that cannot be evaluated for a feature (a type that does not fit, a - `step` or `interpolate` over what is not a number) or comes to nothing - (null, or not a finite number where one is needed) is the property's + `step` or `interpolate` over what is not a number) or is not of the + property's kind (null; not a finite number, a string included, where a + number is needed; not a colour `parseColor` reads, which takes the CSS + colour names; not one of the property's keywords) is the property's default; a legacy function's miss is its `default`, else the property's. A feature whose filter cannot be evaluated is left out. Nothing unsupported throws. diff --git a/src/render/vectorBase/expressions.js b/src/render/vectorBase/expressions.js index 8c36af642..de0329b4e 100644 --- a/src/render/vectorBase/expressions.js +++ b/src/render/vectorBase/expressions.js @@ -53,21 +53,64 @@ const ARITHMETIC = { log2: (args) => Math.log2(args[0]), }; -const NAMED_COLORS = { - black: [0, 0, 0, 1], - white: [255, 255, 255, 1], - red: [255, 0, 0, 1], - green: [0, 128, 0, 1], - blue: [0, 0, 255, 1], - yellow: [255, 255, 0, 1], - gray: [128, 128, 128, 1], - grey: [128, 128, 128, 1], - transparent: [0, 0, 0, 0], -}; +/** The CSS named colours, as `name:rrggbb`. */ +const CSS_NAMES = + 'aliceblue:f0f8ff antiquewhite:faebd7 aqua:00ffff aquamarine:7fffd4 ' + + 'azure:f0ffff beige:f5f5dc bisque:ffe4c4 black:000000 ' + + 'blanchedalmond:ffebcd blue:0000ff blueviolet:8a2be2 brown:a52a2a ' + + 'burlywood:deb887 cadetblue:5f9ea0 chartreuse:7fff00 chocolate:d2691e ' + + 'coral:ff7f50 cornflowerblue:6495ed cornsilk:fff8dc crimson:dc143c ' + + 'cyan:00ffff darkblue:00008b darkcyan:008b8b darkgoldenrod:b8860b ' + + 'darkgray:a9a9a9 darkgreen:006400 darkgrey:a9a9a9 darkkhaki:bdb76b ' + + 'darkmagenta:8b008b darkolivegreen:556b2f darkorange:ff8c00 ' + + 'darkorchid:9932cc darkred:8b0000 darksalmon:e9967a darkseagreen:8fbc8f ' + + 'darkslateblue:483d8b darkslategray:2f4f4f darkslategrey:2f4f4f ' + + 'darkturquoise:00ced1 darkviolet:9400d3 deeppink:ff1493 ' + + 'deepskyblue:00bfff dimgray:696969 dimgrey:696969 dodgerblue:1e90ff ' + + 'firebrick:b22222 floralwhite:fffaf0 forestgreen:228b22 fuchsia:ff00ff ' + + 'gainsboro:dcdcdc ghostwhite:f8f8ff gold:ffd700 goldenrod:daa520 ' + + 'gray:808080 green:008000 greenyellow:adff2f grey:808080 ' + + 'honeydew:f0fff0 hotpink:ff69b4 indianred:cd5c5c indigo:4b0082 ' + + 'ivory:fffff0 khaki:f0e68c lavender:e6e6fa lavenderblush:fff0f5 ' + + 'lawngreen:7cfc00 lemonchiffon:fffacd lightblue:add8e6 ' + + 'lightcoral:f08080 lightcyan:e0ffff lightgoldenrodyellow:fafad2 ' + + 'lightgray:d3d3d3 lightgreen:90ee90 lightgrey:d3d3d3 lightpink:ffb6c1 ' + + 'lightsalmon:ffa07a lightseagreen:20b2aa lightskyblue:87cefa ' + + 'lightslategray:778899 lightslategrey:778899 lightsteelblue:b0c4de ' + + 'lightyellow:ffffe0 lime:00ff00 limegreen:32cd32 linen:faf0e6 ' + + 'magenta:ff00ff maroon:800000 mediumaquamarine:66cdaa mediumblue:0000cd ' + + 'mediumorchid:ba55d3 mediumpurple:9370db mediumseagreen:3cb371 ' + + 'mediumslateblue:7b68ee mediumspringgreen:00fa9a mediumturquoise:48d1cc ' + + 'mediumvioletred:c71585 midnightblue:191970 mintcream:f5fffa ' + + 'mistyrose:ffe4e1 moccasin:ffe4b5 navajowhite:ffdead navy:000080 ' + + 'oldlace:fdf5e6 olive:808000 olivedrab:6b8e23 orange:ffa500 ' + + 'orangered:ff4500 orchid:da70d6 palegoldenrod:eee8aa palegreen:98fb98 ' + + 'paleturquoise:afeeee palevioletred:db7093 papayawhip:ffefd5 ' + + 'peachpuff:ffdab9 peru:cd853f pink:ffc0cb plum:dda0dd powderblue:b0e0e6 ' + + 'purple:800080 rebeccapurple:663399 red:ff0000 rosybrown:bc8f8f ' + + 'royalblue:4169e1 saddlebrown:8b4513 salmon:fa8072 sandybrown:f4a460 ' + + 'seagreen:2e8b57 seashell:fff5ee sienna:a0522d silver:c0c0c0 ' + + 'skyblue:87ceeb slateblue:6a5acd slategray:708090 slategrey:708090 ' + + 'snow:fffafa springgreen:00ff7f steelblue:4682b4 tan:d2b48c teal:008080 ' + + 'thistle:d8bfd8 tomato:ff6347 turquoise:40e0d0 violet:ee82ee ' + + 'wheat:f5deb3 white:ffffff whitesmoke:f5f5f5 yellow:ffff00 ' + + 'yellowgreen:9acd32'; + +const NAMED_COLORS = Object.fromEntries([ + ...CSS_NAMES.split(' ').map((entry) => { + const [name, hex] = entry.split(':'); + return [ + name, + [0, 2, 4].map((i) => parseInt(hex.slice(i, i + 2), 16)).concat(1), + ]; + }), + ['transparent', [0, 0, 0, 0]], +]); /** * A CSS colour as `[r, g, b, a]` (0..255, alpha 0..1): hex, `rgb()`, - * `rgba()`, `hsl()`, `hsla()` and a few names; null for anything else. + * `rgba()`, `hsl()`, `hsla()` and the CSS colour names; null for anything + * else. * @param {unknown} text */ export function parseColor(text) { diff --git a/src/render/vectorBase/paint.js b/src/render/vectorBase/paint.js index a12566e46..3f10bc911 100644 --- a/src/render/vectorBase/paint.js +++ b/src/render/vectorBase/paint.js @@ -23,7 +23,7 @@ */ import { PbfReader } from 'pbf'; import { VectorTile } from '@mapbox/vector-tile'; -import { cssOf, fillTokens } from './expressions.js'; +import { cssOf, fillTokens, parseColor } from './expressions.js'; /** The tile size style zooms are given for, pixels. */ export const STYLE_TILE_SIZE = 512; @@ -94,49 +94,66 @@ function sourceTile(style, url, fetchImpl) { return tile; } -/** Whether a value is nothing: null, undefined or a number that is not one. */ -const nothing = (v) => - v === null || - v === undefined || - (typeof v === 'number' && !Number.isFinite(v)); +/** The values each keyword property takes, as the specification lists them. */ +const KEYWORDS = { + 'line-cap': ['butt', 'round', 'square'], + 'line-join': ['bevel', 'round', 'miter'], + 'text-transform': ['none', 'uppercase', 'lowercase'], + 'text-anchor': [ + 'center', + 'left', + 'right', + 'top', + 'bottom', + 'top-left', + 'top-right', + 'bottom-left', + 'bottom-right', + ], +}; /** - * A value of a layer for a feature. One that cannot be evaluated, or comes - * to nothing, is the property's default, as MapLibre takes it (never the - * last feature's, which a canvas given nothing would keep). + * A value of a layer for a feature, or the property's default where it + * cannot be evaluated. MapLibre then also takes the default for one that is + * not of the property's type, which {@link numberOf}, {@link colorOf} and + * {@link keywordOf} check: a canvas given a value it cannot use ignores it, + * so the last feature's would be drawn. */ -function valueOf(layer, key, f) { +export function valueOf(layer, key, f) { let v; try { v = layer.values[key]?.(f); } catch { v = undefined; } - return nothing(v) ? layer.defaults?.[key] : v; + return v === null || v === undefined ? layer.defaults?.[key] : v; } -/** A number value; the property's default for one that is not a number. */ -function numberOf(layer, key, f) { +/** A number value: a finite number, else the property's default. */ +export function numberOf(layer, key, f) { const v = valueOf(layer, key, f); - const n = typeof v === 'number' || typeof v === 'string' ? Number(v) : NaN; - return Number.isFinite(n) && v !== '' ? n : Number(layer.defaults?.[key]); + return typeof v === 'number' && Number.isFinite(v) + ? v + : Number(layer.defaults?.[key]); } -/** A colour as CSS, a string or `[r, g, b, a]`; else the default (or `or`). */ -function colorOf(layer, key, f, or = layer.defaults?.[key]) { +/** + * A colour value as CSS: one `parseColor` reads, else the default (or + * `or`). + */ +export function colorOf(layer, key, f, or = layer.defaults?.[key]) { const css = (v) => { - if (typeof v === 'string' && v.trim()) return v; - if (Array.isArray(v) && v.length === 4 && v.every(Number.isFinite)) - return cssOf(v); - return null; + const parsed = parseColor(v); + if (!parsed || !parsed.every(Number.isFinite)) return null; + return typeof v === 'string' ? v : cssOf(parsed); }; return css(valueOf(layer, key, f)) ?? css(or); } -/** A keyword value (`line-cap`, `line-join`); the default for no string. */ -function keywordOf(layer, key, f) { +/** A keyword value: one its property takes, else the default. */ +export function keywordOf(layer, key, f) { const v = valueOf(layer, key, f); - return typeof v === 'string' && v ? v : layer.defaults?.[key]; + return KEYWORDS[key]?.includes(v) ? v : layer.defaults?.[key]; } /** Paths a feature's rings or lines in tile pixels. */ @@ -388,7 +405,7 @@ function drawFeature(ctx, layer, feature, f, at, labels, order) { let text = layer.tokens ? fillTokens(String(field ?? ''), f.properties) : String(field ?? ''); - const transform = v('text-transform'); + const transform = keywordOf(layer, 'text-transform', f); if (transform === 'uppercase') text = text.toUpperCase(); if (transform === 'lowercase') text = text.toLowerCase(); text = text.trim(); @@ -423,9 +440,7 @@ function drawFeature(ctx, layer, feature, f, at, labels, order) { opacity: num('text-opacity'), halo: color('text-halo-color'), haloWidth: num('text-halo-width'), - anchor: String( - (layer.values['text-anchor'] && v('text-anchor')) ?? 'center', - ), + anchor: keywordOf(layer, 'text-anchor', f), maxWidth, order, }; diff --git a/src/render/vectorBase/style.js b/src/render/vectorBase/style.js index e95aaac48..35a0abf3f 100644 --- a/src/render/vectorBase/style.js +++ b/src/render/vectorBase/style.js @@ -6,12 +6,8 @@ * and its background. A layer the painter cannot draw is listed in `skipped` * with the reason, never drawn wrong. */ -import { - compileFilter, - compileValue, - cssOf, - Unsupported, -} from './expressions.js'; +import { compileFilter, compileValue, Unsupported } from './expressions.js'; +import { colorOf, numberOf } from './paint.js'; /** Layer types the painter draws. */ export const PAINTED_TYPES = Object.freeze([ @@ -259,25 +255,15 @@ export async function loadVectorStyle( continue; } layers.push(layer); - if (layer.type === 'background' && !background) - try { - const at = { zoom: 0, properties: {}, type: 'Polygon' }; - const value = layer.values['background-color'](at); - // A colour as a string, or `[r, g, b, a]` (as `to-color` gives one). - const color = - typeof value === 'string' - ? value - : Array.isArray(value) && - value.length === 4 && - value.every(Number.isFinite) - ? cssOf(value) - : null; - const opacity = layer.values['background-opacity'](at); - background = - color && Number.isFinite(opacity) ? { color, opacity } : null; - } catch { - background = null; - } + if (layer.type === 'background' && !background) { + // As it paints: a value that cannot be evaluated, or is not a + // colour or number, is the property's default. + const at = { zoom: 0, properties: {}, type: 'Polygon' }; + background = { + color: colorOf(layer, 'background-color', at), + opacity: numberOf(layer, 'background-opacity', at), + }; + } } return { url: styleUrl, diff --git a/src/render/vectorBase/vectorBase.test.mjs b/src/render/vectorBase/vectorBase.test.mjs index 4902ba719..f453c5f69 100644 --- a/src/render/vectorBase/vectorBase.test.mjs +++ b/src/render/vectorBase/vectorBase.test.mjs @@ -605,3 +605,82 @@ test('labels of one layer are placed in their features’ order, the first winni ['First'], ); }); + +test('a colour, keyword or number of the wrong kind is the property’s default, never the last feature’s', async () => { + const fills = await paintOne( + { + id: 'water', + type: 'fill', + 'source-layer': 'water', + paint: { 'fill-color': ['get', 'c'] }, + }, + { + water: [ + { type: 'Polygon', geometry: FULL, properties: { c: '#00f' } }, + { type: 'Polygon', geometry: FULL, properties: { c: 'bogus' } }, + { type: 'Polygon', geometry: FULL, properties: { c: 'orange' } }, + ], + }, + ); + assert.deepEqual( + fills.filter(([k]) => k === '=fillStyle').map(([, v]) => v), + ['#00f', '#000000', 'orange'], + ); + const line = [ + [ + [0, 2048], + [4096, 2048], + ], + ]; + const lines = await paintOne( + { + id: 'roads', + type: 'line', + 'source-layer': 'roads', + layout: { 'line-join': ['get', 'j'], 'line-cap': ['get', 'cap'] }, + paint: { 'line-width': ['get', 'w'] }, + }, + { + roads: [ + { + type: 'LineString', + geometry: line, + properties: { j: 'round', cap: 'square', w: 3 }, + }, + { + type: 'LineString', + geometry: line, + properties: { j: 'pointy', cap: 7, w: '5' }, + }, + ], + }, + ); + const set = (key) => lines.filter(([k]) => k === `=${key}`).map(([, v]) => v); + assert.deepEqual(set('lineJoin'), ['round', 'miter']); + assert.deepEqual(set('lineCap'), ['square', 'butt']); + assert.deepEqual(set('lineWidth'), [3, 1], 'a string is not a number'); +}); + +test('a style’s background takes the defaults where its values cannot be used', async () => { + const background = async (paint) => { + const { fetch } = fetchOver({ + 'https://example.test/s.json': { + version: 8, + sources: {}, + layers: [{ id: 'bg', type: 'background', paint }], + }, + }); + return (await loadVectorStyle('https://example.test/s.json', fetch)) + .background; + }; + const black = { color: '#000000', opacity: 1 }; + assert.deepEqual( + await background({ 'background-color': ['get', 'none'] }), + black, + ); + assert.deepEqual(await background({ 'background-color': 'bogus' }), black); + assert.deepEqual( + await background({ 'background-opacity': ['/', 1, ['get', 'x']] }), + black, + ); +});