@sakuzu/maplibre-gl-draw 1.0.0

package/dist/view/shaders/retained-origin.js

@@ -0,0 +1,67 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/** The largest screen error of the baked offsets that is accepted (CSS px) */
+export const RETAINED_ORIGIN_TOLERANCE_PX = 0.1;
+/** The unit roundoff of Float32 */
+const FLOAT32_ROUNDOFF = 2 ** -24;
+/** The width of the world in CSS px at zoom 0 (the tile size of maplibre) */
+const WORLD_SIZE_PX = 512;
+/** The latitude where Web Mercator stops (the scale diverges at the poles) */
+const MAX_MERCATOR_LATITUDE = 85.0511287798;
+/**
+ * The center of a bounding box
+ */
+export function boundsCenter(bounds) {
+    return [(bounds.minX + bounds.maxX) / 2, (bounds.minY + bounds.maxY) / 2];
+}
+/**
+ * The screen error (CSS px) that the baked offsets of a batch leave in a region
+ *
+ * It is the bound described in the module comment, measured at the corner of the region
+ * farthest from the origin. A latitude difference is longer on screen by 1 / cos φ, so it is
+ * weighted with the highest latitude of the region.
+ *
+ * @param origin The origin of the batch
+ * @param region The region on screen (longitude / latitude)
+ * @param zoom The zoom of the camera
+ */
+export function retainedOriginErrorPx(origin, region, zoom) {
+    const dLng = Math.max(Math.abs(region.minX - origin[0]), Math.abs(region.maxX - origin[0]));
+    const dLat = Math.max(Math.abs(region.minY - origin[1]), Math.abs(region.maxY - origin[1]));
+    const lat = Math.min(Math.max(Math.abs(region.minY), Math.abs(region.maxY)), MAX_MERCATOR_LATITUDE);
+    const latScale = 1 / Math.cos((lat * Math.PI) / 180);
+    const pxPerDegree = (WORLD_SIZE_PX * 2 ** zoom) / 360;
+    return 2 * FLOAT32_ROUNDOFF * Math.max(dLng, dLat * latScale) * pxPerDegree;
+}
+/**
+ * The origin a batch should be built with again for the current view (null = keep it)
+ *
+ * The region on screen is the extent of the batch clipped to the view. When the current origin
+ * leaves more than the tolerance there, the center of that region is proposed, provided it at
+ * least halves the error (so that a region that is large on screen, where no origin can do
+ * better, does not rebuild every frame).
+ *
+ * @param origin The origin the batch was built with
+ * @param extent The extent of the batch (null when unknown: kept)
+ * @param view The view (null when unknown: the whole extent is taken as on screen)
+ * @param zoom The zoom of the camera
+ */
+export function rebasedRetainedOrigin(origin, extent, view, zoom) {
+    if (!extent)
+        return null;
+    const region = view
+        ? {
+            minX: Math.max(extent.minX, view.minX),
+            minY: Math.max(extent.minY, view.minY),
+            maxX: Math.min(extent.maxX, view.maxX),
+            maxY: Math.min(extent.maxY, view.maxY),
+        }
+        : extent;
+    if (!(region.minX <= region.maxX && region.minY <= region.maxY))
+        return null;
+    const error = retainedOriginErrorPx(origin, region, zoom);
+    if (!(error > RETAINED_ORIGIN_TOLERANCE_PX))
+        return null;
+    const candidate = boundsCenter(region);
+    return retainedOriginErrorPx(candidate, region, zoom) < error / 2 ? candidate : null;
+}

package/dist/view/shaders/terrain-shade.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Vertex side: GLSL that hands over the sample position for the shading
+ *
+ * Place it after OFFSET_MODE_GLSL and call `emitShadeOffset(a_pos)` inside
+ * main. A draw that does not call it leaves the varying undefined, so a shader
+ * that has a fill must call it exactly once on every branch.
+ */
+export declare const TERRAIN_SHADE_VERTEX_GLSL = "\nout vec2 v_shade_offset;\n\nvoid emitShadeOffset(vec2 lngLatOffset) {\n    v_shade_offset = shade_mercator_offset(lngLatOffset);\n}\n";
+/**
+ * Fragment side: GLSL that produces the coefficient applied to the polygon fill
+ *
+ * `terrainFillShade()` returns 1.0 on flat ground and when terrain is
+ * disabled. When terrain is disabled (`u_shade_strength` is 0) it returns
+ * without reading the DEM, so the cost and the pixels are the same as before
+ * terrain was introduced.
+ *
+ * The shading is applied even on frames that draw polygons and lines flat (the
+ * zoomed-out band). Stopping the vertex displacement is a measure to avoid
+ * cliffs; it does not mean the relief of the ground surface no longer needs to
+ * be readable. If anything, that band is exactly the boundary where the paths
+ * swap over.
+ */
+export declare const TERRAIN_SHADE_FRAGMENT_GLSL: string;

package/dist/view/shaders/terrain-shade.js

@@ -0,0 +1,93 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Terrain shading applied to the polygon fill of the vertex displacement path
+ *
+ * There are two paths for laying a polygon fill onto the ground surface:
+ * analytic drape (painting it as pixels of the ground surface) and vertex
+ * displacement (lifting the vertices of the feature and painting them). The
+ * path is switched by cost, so even on the same map it swaps over depending on
+ * the camera angle and the amount of data. If the fill looks different between
+ * the paths, the picture jumps at that switch. In practice it showed up as
+ * "tilting makes relief appear on the polygon, and straightening it brings
+ * back a uniform color".
+ *
+ * So the same shading as the analytic drape is applied to the fill of the
+ * vertex displacement path as well. The formula shares the single place in
+ * `terrain/shade.ts` (same light source, same normalization, same clamp); only
+ * the way samples are taken differs. The drape reads the DEM in tile
+ * coordinates, while this one reads the DEM atlas with the Mercator relative
+ * coordinates handed over from the vertex.
+ *
+ * It is applied only to polygon fills. Lines, points, labels and handles are
+ * left unshaded for readability (the same convention as the drape path).
+ */
+import { TERRAIN_SHADE_CORE_GLSL } from '../terrain/shade.js';
+import { DEM_SAMPLE_GLSL } from './helpers.js';
+/**
+ * Vertex side: GLSL that hands over the sample position for the shading
+ *
+ * Place it after OFFSET_MODE_GLSL and call `emitShadeOffset(a_pos)` inside
+ * main. A draw that does not call it leaves the varying undefined, so a shader
+ * that has a fill must call it exactly once on every branch.
+ */
+export const TERRAIN_SHADE_VERTEX_GLSL = `
+out vec2 v_shade_offset;
+
+void emitShadeOffset(vec2 lngLatOffset) {
+    v_shade_offset = shade_mercator_offset(lngLatOffset);
+}
+`;
+/**
+ * Fragment side: GLSL that produces the coefficient applied to the polygon fill
+ *
+ * `terrainFillShade()` returns 1.0 on flat ground and when terrain is
+ * disabled. When terrain is disabled (`u_shade_strength` is 0) it returns
+ * without reading the DEM, so the cost and the pixels are the same as before
+ * terrain was introduced.
+ *
+ * The shading is applied even on frames that draw polygons and lines flat (the
+ * zoomed-out band). Stopping the vertex displacement is a measure to avoid
+ * cliffs; it does not mean the relief of the ground surface no longer needs to
+ * be readable. If anything, that band is exactly the boundary where the paths
+ * swap over.
+ */
+export const TERRAIN_SHADE_FRAGMENT_GLSL = `
+in vec2 v_shade_offset;
+
+// Shading (an aid for reading the terrain). Same light source and same formula as the ground,
+// applied to the fill only
+uniform vec3 u_light_dir;      // unit vector in the map coordinate system (east, north, up)
+uniform float u_shade_strength;
+` +
+    DEM_SAMPLE_GLSL +
+    TERRAIN_SHADE_CORE_GLSL +
+    `
+float terrainFillShade() {
+    if (u_shade_strength <= 0.0) return 1.0;
+
+    // The sample width is one texel of the DEM atlas. rect.zw = 1/width, 1/height
+    // (Mercator), so the Mercator width of a texel is 1/(rect.zw * size).
+    vec2 texel = 1.0 / max(u_dem_atlas_rect.zw * u_dem_atlas_size, vec2(1e-9));
+
+    // The ground distance of Mercator 1.0 (meters). It is exactly the reciprocal of the
+    // meters -> Mercator z coefficient (u_elevation_params.x). It uses the same value as the
+    // conversion applied when the vertex adds the elevation, so the unit of the gradient
+    // never drifts.
+    float meters = 1.0 / max(u_elevation_params.x, 1e-12);
+
+    // Outside the atlas, the clamp in dem_elevation_meters returns the edge value. The
+    // gradient goes thin there, but since the atlas covers the terrain tiles in view, this
+    // does not happen in the range where the polygon fill is applied (only the coarse tiles
+    // on the horizon side fall outside the range).
+    float ex1 = dem_elevation_meters(v_shade_offset + vec2(texel.x, 0.0));
+    float ex0 = dem_elevation_meters(v_shade_offset - vec2(texel.x, 0.0));
+    float ey1 = dem_elevation_meters(v_shade_offset + vec2(0.0, texel.y));
+    float ey0 = dem_elevation_meters(v_shade_offset - vec2(0.0, texel.y));
+
+    float dzdEast = (ex1 - ex0) / (2.0 * texel.x * meters);
+    // Mercator y points south, so flip north
+    float dzdNorth = -(ey1 - ey0) / (2.0 * texel.y * meters);
+    return terrainShadeFromGradient(dzdEast, dzdNorth);
+}
+`;

package/dist/view/style-rule.d.ts

@@ -0,0 +1,166 @@
+/**
+ * Style rules of a layer
+ *
+ * A set of pure functions that evaluate the declarative style rule a layer holds
+ * (`Layer.styleRule`) and derive a color from the attributes of a feature. So that the
+ * same functions can be used both from rendering (FeatureDrawer) and from
+ * datasets, they depend on neither the Store, nor WebGL, nor the DOM.
+ *
+ * The priority of evaluation is "the feature's own color > the layer's rule > the default
+ * color". Whether a feature has its own color is decided by the presence of the color
+ * property of the relevant channel, to match the existing style resolution (FeatureDrawer
+ * merges `style.fillColor` and the like into the defaults property by property).
+ * Therefore the rule does apply to a feature that only holds things other than colors,
+ * such as `{ strokeWidth: 3 }`.
+ *
+ * When the attribute is missing or its type does not match, it falls back to the rule's
+ * `other` rather than to the default color. This is so that the caller can tell
+ * "the rule is not taking effect" apart from "there is no value".
+ */
+import { type Messages } from '../messages.js';
+import type { Feature, FeatureStyle, FeatureType, StyleRule } from '../store/types.js';
+/**
+ * One row of a legend derived by {@link deriveLegend}: a label and a color.
+ *
+ * It holds only a label and a color. The library does not draw the legend UI.
+ */
+export interface LegendEntry {
+    /** The displayed label */
+    label: string;
+    /** The color (in #RRGGBB form) */
+    color: string;
+}
+/**
+ * Which color property of a feature style the rule color goes to, by geometry type.
+ *
+ * It expresses which style property the rule's color becomes, per geometry type.
+ *
+ * - point: `pointColor` (Point / MultiPoint)
+ * - stroke: `strokeColor` (LineString / MultiLineString / Freehand)
+ * - fill: `fillColor` (Polygon / MultiPolygon / Circle)
+ */
+export type StyleRuleChannel = 'point' | 'stroke' | 'fill';
+/**
+ * Returns the channel that carries the rule color for a feature type.
+ *
+ * Types other than the known ones (Image and custom types) return 'fill'.
+ *
+ * @param type The feature type
+ * @returns `'point'`, `'stroke'` or `'fill'`
+ */
+export declare function getStyleRuleChannel(type: FeatureType): StyleRuleChannel;
+/**
+ * Evaluates a style rule against the attributes of a feature and returns a color.
+ *
+ * When the attribute is missing or its type does not match, the rule's `other` is
+ * returned. `single` does not look at attributes, so it is always the same color.
+ * `categorical` matches strings, numbers and booleans by `String(value)`; `graduated` and
+ * `continuous` take finite numbers only (a numeric string gives `other`). `continuous`
+ * clamps values outside `min`..`max` and returns the first ramp color when `max <= min`. It
+ * is a pure function.
+ *
+ * @param rule The style rule
+ * @param properties The attributes of the feature
+ * @returns The color in `#RRGGBB` form
+ *
+ * @example
+ * ```ts
+ * import { evaluateStyleRule, type StyleRule } from '@sakuzu/maplibre-gl-draw';
+ *
+ * const rule: StyleRule = {
+ *   kind: 'graduated',
+ *   property: 'population',
+ *   breaks: [1000, 10000],
+ *   colors: ['#fee8c8', '#fdbb84', '#e34a33'],
+ *   other: '#cccccc',
+ * };
+ * evaluateStyleRule(rule, { population: 5000 }); // '#fdbb84'
+ * evaluateStyleRule(rule, { population: '5000' }); // '#cccccc' (not a number)
+ * evaluateStyleRule(rule, {}); // '#cccccc'
+ * ```
+ */
+export declare function evaluateStyleRule(rule: StyleRule, properties: Record<string, unknown> | undefined): string;
+/**
+ * Returns the rule color of a feature, or null when there is no rule.
+ *
+ * Returns null when there is no rule. The precedence of the feature's own style is a
+ * per-channel decision, so it is not decided here (`applyRuleColor` does it).
+ *
+ * @param feature The target feature
+ * @param rule The style rule of the layer (undefined when it is not set)
+ * @returns The rule color (in #RRGGBB form). null when there is no rule
+ */
+export declare function resolveRuleColor(feature: Feature, rule: StyleRule | undefined): string | null;
+/**
+ * Returns the style of a feature with the rule color put on the color property of a
+ * channel.
+ *
+ * A feature that has its own color property for the relevant channel beats the rule, so
+ * in that case the original style is returned as is. Properties other than colors (stroke
+ * width, opacity and so on) are used together with the rule color.
+ *
+ * @param style The feature's own style
+ * @param ruleColor The rule color (null means there is no rule)
+ * @param channel The channel that carries the rule color
+ * @returns The effective style: the input itself when `ruleColor` is null or the feature
+ *   has its own color for the channel, otherwise a new object
+ */
+export declare function applyRuleColor(style: FeatureStyle | undefined, ruleColor: string | null, channel: StyleRuleChannel): FeatureStyle | undefined;
+/**
+ * Returns the effective style of a feature under the style rule of its layer.
+ *
+ * A combination of `resolveRuleColor` and `applyRuleColor`. The rendering path that uses a
+ * cache caches only the resolution of the rule color, so it calls the two separately.
+ *
+ * @param feature The target feature
+ * @param rule The style rule of the layer
+ * @param channel The channel that carries the rule color
+ * @returns The effective style
+ */
+export declare function resolveFeatureStyle(feature: Feature, rule: StyleRule | undefined, channel: StyleRuleChannel): FeatureStyle | undefined;
+/**
+ * Derives the rows of a legend from a style rule; the library does not draw the legend.
+ *
+ * Every label that is not a value of the data comes from the messages table (English by
+ * default; see `Messages`). The rules for turning labels into strings are as follows.
+ *
+ * - single: 1 entry. The label is `legendAll` ("All")
+ * - categorical: the keys of `map` become the labels as they are, lined up in declaration
+ *   order. `legendOther` ("Other", the color of `other`) is appended at the end
+ * - graduated: the boundary notation of each class (`legendBelow` "Below 10",
+ *   `legendRange` "10 to below 20", `legendAtLeast` "20 or more"). `legendOther` is
+ *   appended at the end
+ * - continuous: only the 2 end points `min` and `max` (no intermediate colors).
+ *   `legendOther` is appended at the end
+ *
+ * Numbers are turned into strings with `String()`. Locale formatting is up to the caller.
+ *
+ * @param rule The style rule
+ * @param messages The entries of the messages table to use (default: `MESSAGES_EN`;
+ *   missing entries fall back to it)
+ * @returns The legend rows, in the order to show them
+ *
+ * @example
+ * ```ts
+ * import { deriveLegend, type StyleRule } from '@sakuzu/maplibre-gl-draw';
+ *
+ * const rule: StyleRule = {
+ *   kind: 'graduated',
+ *   property: 'population',
+ *   breaks: [1000, 10000],
+ *   colors: ['#fee8c8', '#fdbb84', '#e34a33'],
+ *   other: '#cccccc',
+ * };
+ * deriveLegend(rule);
+ * // [
+ * //   { label: 'Below 1000', color: '#fee8c8' },
+ * //   { label: '1000 to below 10000', color: '#fdbb84' },
+ * //   { label: '10000 or more', color: '#e34a33' },
+ * //   { label: 'Other', color: '#cccccc' },
+ * // ]
+ *
+ * // In the language of the host application
+ * deriveLegend(rule, { legendOther: 'Autres', legendBelow: (upper) => `Moins de ${upper}` });
+ * ```
+ */
+export declare function deriveLegend(rule: StyleRule, messages?: Partial<Messages>): LegendEntry[];

package/dist/view/style-rule.js

@@ -0,0 +1,300 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Style rules of a layer
+ *
+ * A set of pure functions that evaluate the declarative style rule a layer holds
+ * (`Layer.styleRule`) and derive a color from the attributes of a feature. So that the
+ * same functions can be used both from rendering (FeatureDrawer) and from
+ * datasets, they depend on neither the Store, nor WebGL, nor the DOM.
+ *
+ * The priority of evaluation is "the feature's own color > the layer's rule > the default
+ * color". Whether a feature has its own color is decided by the presence of the color
+ * property of the relevant channel, to match the existing style resolution (FeatureDrawer
+ * merges `style.fillColor` and the like into the defaults property by property).
+ * Therefore the rule does apply to a feature that only holds things other than colors,
+ * such as `{ strokeWidth: 3 }`.
+ *
+ * When the attribute is missing or its type does not match, it falls back to the rule's
+ * `other` rather than to the default color. This is so that the caller can tell
+ * "the rule is not taking effect" apart from "there is no value".
+ */
+import { MESSAGES_EN, resolveMessages } from '../messages.js';
+import { interpolateHexColor } from '../shared/utils/color.js';
+/** The name of the FeatureStyle color property corresponding to each channel */
+const CHANNEL_COLOR_PROPERTY = {
+    point: 'pointColor',
+    stroke: 'strokeColor',
+    fill: 'fillColor',
+};
+/**
+ * Returns the channel that carries the rule color for a feature type.
+ *
+ * Types other than the known ones (Image and custom types) return 'fill'.
+ *
+ * @param type The feature type
+ * @returns `'point'`, `'stroke'` or `'fill'`
+ */
+export function getStyleRuleChannel(type) {
+    switch (type) {
+        case 'Point':
+        case 'MultiPoint':
+            return 'point';
+        case 'LineString':
+        case 'MultiLineString':
+        case 'Freehand':
+            return 'stroke';
+        default:
+            return 'fill';
+    }
+}
+/**
+ * Computes the key string of categorical
+ *
+ * Strings, numbers and booleans are turned into strings with `String()` and matched
+ * against the keys of the map. Anything else (objects, arrays, null, undefined) is not
+ * matched.
+ */
+function toCategoricalKey(value) {
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? String(value) : null;
+    if (typeof value === 'boolean')
+        return String(value);
+    return null;
+}
+/**
+ * Computes the number used by graduated / continuous
+ *
+ * No type conversion is done. Non-numbers (numeric strings included), NaN and Infinity
+ * give null.
+ */
+function toFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+/**
+ * Computes the class of graduated
+ *
+ * `breaks` are the boundary values in ascending order (n of them) and `colors` has n + 1
+ * entries. If the value v is below `breaks[i]` it is `colors[i]`, and if it is below no
+ * boundary at all it is `colors[n]`.
+ */
+function graduatedIndex(breaks, value) {
+    for (let i = 0; i < breaks.length; i++) {
+        if (value < breaks[i])
+            return i;
+    }
+    return breaks.length;
+}
+/**
+ * Evaluates a style rule against the attributes of a feature and returns a color.
+ *
+ * When the attribute is missing or its type does not match, the rule's `other` is
+ * returned. `single` does not look at attributes, so it is always the same color.
+ * `categorical` matches strings, numbers and booleans by `String(value)`; `graduated` and
+ * `continuous` take finite numbers only (a numeric string gives `other`). `continuous`
+ * clamps values outside `min`..`max` and returns the first ramp color when `max <= min`. It
+ * is a pure function.
+ *
+ * @param rule The style rule
+ * @param properties The attributes of the feature
+ * @returns The color in `#RRGGBB` form
+ *
+ * @example
+ * ```ts
+ * import { evaluateStyleRule, type StyleRule } from '@sakuzu/maplibre-gl-draw';
+ *
+ * const rule: StyleRule = {
+ *   kind: 'graduated',
+ *   property: 'population',
+ *   breaks: [1000, 10000],
+ *   colors: ['#fee8c8', '#fdbb84', '#e34a33'],
+ *   other: '#cccccc',
+ * };
+ * evaluateStyleRule(rule, { population: 5000 }); // '#fdbb84'
+ * evaluateStyleRule(rule, { population: '5000' }); // '#cccccc' (not a number)
+ * evaluateStyleRule(rule, {}); // '#cccccc'
+ * ```
+ */
+export function evaluateStyleRule(rule, properties) {
+    if (rule.kind === 'single') {
+        return rule.color;
+    }
+    return evaluateStyleRuleValue(rule, properties?.[rule.property]);
+}
+/**
+ * Evaluates a style rule against the value of the attribute it reads
+ *
+ * The same result as `evaluateStyleRule(rule, { [rule.property]: value })`, for a caller that
+ * holds the attribute as a column rather than as the properties of a feature.
+ *
+ * @internal
+ */
+export function evaluateStyleRuleValue(rule, value) {
+    if (rule.kind === 'single') {
+        return rule.color;
+    }
+    if (rule.kind === 'categorical') {
+        const key = toCategoricalKey(value);
+        if (key === null)
+            return rule.other;
+        const color = rule.map[key];
+        return color ?? rule.other;
+    }
+    const numeric = toFiniteNumber(value);
+    if (numeric === null)
+        return rule.other;
+    if (rule.kind === 'graduated') {
+        const color = rule.colors[graduatedIndex(rule.breaks, numeric)];
+        // An invalid rule whose colors count falls short of breaks + 1 falls back to other
+        return color ?? rule.other;
+    }
+    // continuous: linearly interpolates the 2 colors of the ramp over min..max
+    // (out-of-range values are clamped)
+    const [from, to] = rule.ramp;
+    if (!(rule.max > rule.min))
+        return from;
+    const t = Math.min(1, Math.max(0, (numeric - rule.min) / (rule.max - rule.min)));
+    return interpolateHexColor(from, to, t);
+}
+/**
+ * Returns the rule color of a feature, or null when there is no rule.
+ *
+ * Returns null when there is no rule. The precedence of the feature's own style is a
+ * per-channel decision, so it is not decided here (`applyRuleColor` does it).
+ *
+ * @param feature The target feature
+ * @param rule The style rule of the layer (undefined when it is not set)
+ * @returns The rule color (in #RRGGBB form). null when there is no rule
+ */
+export function resolveRuleColor(feature, rule) {
+    if (!rule)
+        return null;
+    return evaluateStyleRule(rule, feature.properties);
+}
+/**
+ * Returns the style of a feature with the rule color put on the color property of a
+ * channel.
+ *
+ * A feature that has its own color property for the relevant channel beats the rule, so
+ * in that case the original style is returned as is. Properties other than colors (stroke
+ * width, opacity and so on) are used together with the rule color.
+ *
+ * @param style The feature's own style
+ * @param ruleColor The rule color (null means there is no rule)
+ * @param channel The channel that carries the rule color
+ * @returns The effective style: the input itself when `ruleColor` is null or the feature
+ *   has its own color for the channel, otherwise a new object
+ */
+export function applyRuleColor(style, ruleColor, channel) {
+    if (ruleColor === null)
+        return style;
+    const property = CHANNEL_COLOR_PROPERTY[channel];
+    if (style?.[property])
+        return style;
+    return { ...style, [property]: ruleColor };
+}
+/**
+ * Returns the effective style of a feature under the style rule of its layer.
+ *
+ * A combination of `resolveRuleColor` and `applyRuleColor`. The rendering path that uses a
+ * cache caches only the resolution of the rule color, so it calls the two separately.
+ *
+ * @param feature The target feature
+ * @param rule The style rule of the layer
+ * @param channel The channel that carries the rule color
+ * @returns The effective style
+ */
+export function resolveFeatureStyle(feature, rule, channel) {
+    const style = feature.style;
+    return applyRuleColor(style, resolveRuleColor(feature, rule), channel);
+}
+/**
+ * Builds the class label of graduated
+ *
+ * Numbers are turned into strings with `String()` as they are (formatting such as digit
+ * grouping and units is the caller's responsibility).
+ */
+function graduatedLabel(breaks, index, messages) {
+    if (breaks.length === 0)
+        return messages.legendAll;
+    if (index === 0)
+        return messages.legendBelow(String(breaks[0]));
+    if (index >= breaks.length)
+        return messages.legendAtLeast(String(breaks[breaks.length - 1]));
+    return messages.legendRange(String(breaks[index - 1]), String(breaks[index]));
+}
+/**
+ * Derives the rows of a legend from a style rule; the library does not draw the legend.
+ *
+ * Every label that is not a value of the data comes from the messages table (English by
+ * default; see `Messages`). The rules for turning labels into strings are as follows.
+ *
+ * - single: 1 entry. The label is `legendAll` ("All")
+ * - categorical: the keys of `map` become the labels as they are, lined up in declaration
+ *   order. `legendOther` ("Other", the color of `other`) is appended at the end
+ * - graduated: the boundary notation of each class (`legendBelow` "Below 10",
+ *   `legendRange` "10 to below 20", `legendAtLeast` "20 or more"). `legendOther` is
+ *   appended at the end
+ * - continuous: only the 2 end points `min` and `max` (no intermediate colors).
+ *   `legendOther` is appended at the end
+ *
+ * Numbers are turned into strings with `String()`. Locale formatting is up to the caller.
+ *
+ * @param rule The style rule
+ * @param messages The entries of the messages table to use (default: `MESSAGES_EN`;
+ *   missing entries fall back to it)
+ * @returns The legend rows, in the order to show them
+ *
+ * @example
+ * ```ts
+ * import { deriveLegend, type StyleRule } from '@sakuzu/maplibre-gl-draw';
+ *
+ * const rule: StyleRule = {
+ *   kind: 'graduated',
+ *   property: 'population',
+ *   breaks: [1000, 10000],
+ *   colors: ['#fee8c8', '#fdbb84', '#e34a33'],
+ *   other: '#cccccc',
+ * };
+ * deriveLegend(rule);
+ * // [
+ * //   { label: 'Below 1000', color: '#fee8c8' },
+ * //   { label: '1000 to below 10000', color: '#fdbb84' },
+ * //   { label: '10000 or more', color: '#e34a33' },
+ * //   { label: 'Other', color: '#cccccc' },
+ * // ]
+ *
+ * // In the language of the host application
+ * deriveLegend(rule, { legendOther: 'Autres', legendBelow: (upper) => `Moins de ${upper}` });
+ * ```
+ */
+export function deriveLegend(rule, messages) {
+    const table = messages ? resolveMessages(messages) : MESSAGES_EN;
+    if (rule.kind === 'single') {
+        return [{ label: table.legendAll, color: rule.color }];
+    }
+    if (rule.kind === 'categorical') {
+        const entries = Object.keys(rule.map).map((key) => ({
+            label: key,
+            color: rule.map[key],
+        }));
+        entries.push({ label: table.legendOther, color: rule.other });
+        return entries;
+    }
+    if (rule.kind === 'graduated') {
+        const count = Math.min(rule.colors.length, rule.breaks.length + 1);
+        const entries = [];
+        for (let i = 0; i < count; i++) {
+            entries.push({ label: graduatedLabel(rule.breaks, i, table), color: rule.colors[i] });
+        }
+        entries.push({ label: table.legendOther, color: rule.other });
+        return entries;
+    }
+    return [
+        { label: String(rule.min), color: rule.ramp[0] },
+        { label: String(rule.max), color: rule.ramp[1] },
+        { label: table.legendOther, color: rule.other },
+    ];
+}