@honua/app-platform 0.0.20-alpha.0

package/controls/layer-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layer-list.d.ts","sourceRoot":"","sources":["../../../src/controls/layer-list.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,OAAO,EACL,eAAe,EAMhB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAA8B,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAEvG;;;;GAIG;AACH,qBAAa,qBAAsB,SAAQ,eAAe;;IACxD,WAAkB,kBAAkB,IAAI,MAAM,EAAE,CAE/C;IAQD,gEAAgE;IAChE,IAAW,GAAG,IAAI,iBAAiB,GAAG,SAAS,CAE9C;IAED,IAAW,GAAG,CAAC,GAAG,EAAE,iBAAiB,GAAG,SAAS,EAMhD;IAED,sEAAsE;IAC/D,OAAO,CAAC,GAAG,EAAE,iBAAiB,GAAG,IAAI;IAI5C,0CAA0C;IAC1C,IAAW,QAAQ,IAAI,SAAS,qBAAqB,EAAE,CAEtD;IAED,IAAW,QAAQ,CAAC,QAAQ,EAAE,SAAS,qBAAqB,EAAE,EAG7D;IAED,qFAAqF;IACrF,IAAW,WAAW,IAAI,OAAO,CAEhC;IAED,IAAW,WAAW,CAAC,KAAK,EAAE,OAAO,EAIpC;IAED,2DAA2D;IACpD,OAAO,IAAI,IAAI;IAItB;;;;OAIG;IACI,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO;IAiBxD,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IAmB/F,iBAAiB,IAAI,IAAI;IASzB,oBAAoB,IAAI,IAAI;IA4EnC,SAAS,CAAC,MAAM,IAAI,IAAI;CAuEzB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,wBAA2B,GAAG,IAAI,CAK9E"}

package/controls/layer-list.js

@@ -0,0 +1,375 @@
+/**
+ * `<honua-layer-list>` — framework-free custom element rendering a checkbox
+ * row per overlay so users can toggle MapLibre overlay layers on and off
+ * (issue #280, closing umbrella #274).
+ *
+ * Each overlay groups one or more style layer ids; toggling a row writes each
+ * layer's `visibility` layout property (`"visible"` / `"none"`) on the map.
+ * The element never imports `maplibre-gl` or the SDK core — it drives any
+ * MapLibre `Map` through the duck-typed {@link HonuaLayerListMap} interface,
+ * keeping the `@honua/sdk-js/controls` entry independent of the core bundle.
+ *
+ * ## Input modes
+ * - **Property** (preferred) — assign the `overlays` property a
+ *   {@link HonuaLayerListOverlay} array.
+ * - **Attribute** — set the `overlays` attribute to a JSON array of the same
+ *   shape (matching how `<honua-basemap-switcher>` accepts `bases` JSON).
+ *
+ * ## Wiring
+ * - `element.map = map` (any MapLibre `Map`) or `element.connect(map)`;
+ * - declaratively via `for="<honua-map id>"` — same idiom as
+ *   `<honua-basemap-switcher>` / `<honua-legend>` (resolves `.map` from the
+ *   referenced element and listens for `honua-map-ready`).
+ *
+ * ## Reactivity
+ * - With the `auto-refresh` attribute the element subscribes to the map's
+ *   `styledata` event while connected and re-syncs each checkbox's checked
+ *   state from the map's current `visibility` (external style edits,
+ *   visibility toggled elsewhere, layers seeded later).
+ *
+ * ## Attributes
+ * - `overlays` — JSON array of {@link HonuaLayerListOverlay} (the `overlays`
+ *   property is preferred for non-trivial configs).
+ * - `for` — id of the map-providing element, see Wiring.
+ * - `label` — accessible name of the list (default "Layers").
+ * - `auto-refresh` — boolean; see Reactivity.
+ *
+ * ## CSS parts
+ * `root`, `row`, `checkbox`, `label`, and `badge` (the "not seeded" hint
+ * shown on a disabled row whose style layers are all missing). Structural CSS
+ * only — theme via `::part()`.
+ *
+ * ## Accessibility
+ * Rows are real `<label>` + `<input type="checkbox">` pairs; an overlay whose
+ * style layers are all missing renders disabled with a `badge` part/slot.
+ */
+import { HTMLElementBase, escapeAttribute, escapeHtml, globalDom, listenForHonuaMapReady, resolveHonuaMapFromContext, } from "./element-utils.js";
+/**
+ * Custom element implementing the overlay layer list. Registered as
+ * `honua-layer-list` by `defineHonuaControls` (which runs automatically on
+ * import of the controls entry when a `customElements` registry exists).
+ */
+export class HonuaLayerListElement extends HTMLElementBase {
+    static get observedAttributes() {
+        return ["overlays", "for", "label", "auto-refresh"];
+    }
+    #map;
+    #overlays = [];
+    #connected = false;
+    #disposeMapReadyListener;
+    #styledataListener;
+    /** The MapLibre map this list toggles overlay visibility on. */
+    get map() {
+        return this.#map;
+    }
+    set map(map) {
+        if (this.#map === map)
+            return;
+        this.#unsubscribeStyledata();
+        this.#map = map;
+        this.#subscribeStyledata();
+        this.render();
+    }
+    /** Wires the list to a MapLibre map. Equivalent to setting `.map`. */
+    connect(map) {
+        this.map = map;
+    }
+    /** The registered overlay definitions. */
+    get overlays() {
+        return this.#overlays;
+    }
+    set overlays(overlays) {
+        this.#overlays = normalizeOverlays(overlays);
+        this.render();
+    }
+    /** Refresh automatically on the map's `styledata` event. Reflects `auto-refresh`. */
+    get autoRefresh() {
+        return this.#hasAttr("auto-refresh");
+    }
+    set autoRefresh(value) {
+        if (typeof this.setAttribute !== "function")
+            return;
+        if (value)
+            this.setAttribute("auto-refresh", "");
+        else
+            this.removeAttribute?.("auto-refresh");
+    }
+    /** Re-syncs checkbox state from the map and re-renders. */
+    refresh() {
+        this.render();
+    }
+    /**
+     * Shows or hides the overlay with the given id, writing each of its style
+     * layers' `visibility`. Returns `true` when the overlay was found and at
+     * least one of its layers exists on the map. Dispatches `change`.
+     */
+    setVisible(overlayId, visible) {
+        const overlay = this.#overlays.find((candidate) => candidate.id === overlayId);
+        if (!overlay)
+            return false;
+        const map = this.#map;
+        if (!map)
+            return false;
+        let applied = false;
+        for (const layerId of overlay.layers) {
+            if (!this.#layerExists(layerId))
+                continue;
+            map.setLayoutProperty(layerId, "visibility", visible ? "visible" : "none");
+            applied = true;
+        }
+        if (!applied)
+            return false;
+        this.#syncRow(overlayId);
+        this.#dispatchChange({ id: overlayId, visible });
+        return true;
+    }
+    attributeChangedCallback(name, _oldValue, newValue) {
+        if (name === "overlays") {
+            const parsed = parseOverlays(newValue);
+            if (parsed)
+                this.overlays = parsed;
+            return;
+        }
+        if (name === "for") {
+            this.#resolveMapFromContext();
+            return;
+        }
+        if (name === "auto-refresh") {
+            if (newValue === null)
+                this.#unsubscribeStyledata();
+            else
+                this.#subscribeStyledata();
+            return;
+        }
+        // "label" only changes the rendering.
+        this.render();
+    }
+    connectedCallback() {
+        this.#connected = true;
+        this.#ensureShadowRoot();
+        this.#listenForMapReady();
+        this.#resolveMapFromContext();
+        this.#subscribeStyledata();
+        this.render();
+    }
+    disconnectedCallback() {
+        this.#connected = false;
+        this.#disposeMapReadyListener?.();
+        this.#disposeMapReadyListener = undefined;
+        this.#unsubscribeStyledata();
+    }
+    // ── map wiring (matches the `for` + ready-event idiom) ──────
+    #listenForMapReady() {
+        if (this.#disposeMapReadyListener)
+            return;
+        this.#disposeMapReadyListener = listenForHonuaMapReady(this, (map) => {
+            const forId = this.#attr("for");
+            if (!forId && this.map)
+                return;
+            this.map = map;
+        });
+    }
+    #resolveMapFromContext() {
+        if (this.map)
+            return;
+        const map = resolveHonuaMapFromContext(this);
+        if (map)
+            this.map = map;
+    }
+    #subscribeStyledata() {
+        if (this.#styledataListener || !this.#connected || !this.autoRefresh)
+            return;
+        const map = this.#map;
+        if (!map || typeof map.on !== "function")
+            return;
+        const listener = () => this.refresh();
+        map.on("styledata", listener);
+        this.#styledataListener = listener;
+    }
+    #unsubscribeStyledata() {
+        const listener = this.#styledataListener;
+        if (!listener)
+            return;
+        this.#styledataListener = undefined;
+        this.#map?.off?.("styledata", listener);
+    }
+    // ── overlay state ──────────────────────────────────────────
+    /** Whether a style layer is present on the current map (drives not-seeded). */
+    #layerExists(layerId) {
+        const map = this.#map;
+        if (!map?.getLayer)
+            return false;
+        return map.getLayer(layerId) != null;
+    }
+    /** True when at least one of the overlay's style layers exists on the map. */
+    #isSeeded(overlay) {
+        return overlay.layers.some((layerId) => this.#layerExists(layerId));
+    }
+    /**
+     * Whether an overlay reads as visible: visible unless every present layer's
+     * `visibility` is `"none"`. Unseeded overlays read as unchecked.
+     */
+    #isVisible(overlay) {
+        const map = this.#map;
+        if (!map)
+            return false;
+        for (const layerId of overlay.layers) {
+            if (!this.#layerExists(layerId))
+                continue;
+            if (map.getLayoutProperty?.(layerId, "visibility") !== "none")
+                return true;
+        }
+        return false;
+    }
+    // ── rendering ──────────────────────────────────────────────
+    #ensureShadowRoot() {
+        if (!this.shadowRoot && typeof this.attachShadow === "function") {
+            this.attachShadow({ mode: "open" });
+        }
+    }
+    render() {
+        const root = this.shadowRoot;
+        if (!root)
+            return;
+        const label = this.#attr("label") ?? "Layers";
+        root.innerHTML = `
+      <style>${structuralStyles()}</style>
+      <div part="root" class="root" role="group" aria-label="${escapeAttribute(label)}">
+        ${this.#overlays.map((overlay) => this.#renderRow(overlay)).join("")}
+      </div>
+    `;
+        this.#bindRows(root);
+    }
+    #renderRow(overlay) {
+        const seeded = this.#isSeeded(overlay);
+        const checked = seeded && this.#isVisible(overlay);
+        const attribution = overlay.attribution
+            ? `<span part="attribution" class="attribution">${escapeHtml(overlay.attribution)}</span>`
+            : "";
+        const badge = seeded ? "" : `<span part="badge" class="badge"><slot name="not-seeded">Not seeded</slot></span>`;
+        return `
+      <label part="row" class="row" data-overlay-id="${escapeAttribute(overlay.id)}"${seeded ? "" : " data-not-seeded"}>
+        <input
+          part="checkbox"
+          class="checkbox"
+          type="checkbox"
+          ${checked ? "checked" : ""}
+          ${seeded ? "" : "disabled"}
+          data-overlay-id="${escapeAttribute(overlay.id)}"
+        />
+        <span part="label" class="label">${escapeHtml(overlay.label)}</span>
+        ${attribution}
+        ${badge}
+      </label>
+    `;
+    }
+    #bindRows(root) {
+        root.querySelectorAll("input[data-overlay-id]").forEach((input) => {
+            input.addEventListener("change", () => {
+                const overlayId = input.dataset.overlayId;
+                if (overlayId)
+                    this.setVisible(overlayId, input.checked);
+            });
+        });
+    }
+    /** Re-syncs a single row's checked state in place (preserves focus). */
+    #syncRow(overlayId) {
+        const root = this.shadowRoot;
+        if (!root || typeof root.querySelector !== "function")
+            return;
+        const overlay = this.#overlays.find((candidate) => candidate.id === overlayId);
+        if (!overlay)
+            return;
+        const input = root.querySelector(`input[data-overlay-id="${cssEscape(overlayId)}"]`);
+        if (input)
+            input.checked = this.#isSeeded(overlay) && this.#isVisible(overlay);
+    }
+    // ── attribute helpers (safe under Node test stubs) ──────────
+    #attr(name) {
+        return typeof this.getAttribute === "function" ? this.getAttribute(name) : null;
+    }
+    #hasAttr(name) {
+        if (typeof this.hasAttribute === "function")
+            return this.hasAttribute(name);
+        return this.#attr(name) !== null;
+    }
+    #dispatchChange(detail) {
+        if (!globalDom.CustomEvent || typeof this.dispatchEvent !== "function")
+            return;
+        this.dispatchEvent(new globalDom.CustomEvent("change", { bubbles: true, composed: true, detail }));
+    }
+}
+/**
+ * Registers the layer-list custom element (`honua-layer-list`). Skips the
+ * registration when the tag is already defined.
+ *
+ * Unlike the other controls-kit elements, this is **opt-in** and is NOT run by
+ * the blanket `defineHonuaControls()` / module-load auto-registration. The
+ * `web-components` entry ships its own (controller-driven) `honua-layer-list`
+ * under the same tag, and that kit auto-registers on import. Auto-registering
+ * the controls variant too would let it silently win the tag in apps that load
+ * both kits (the order is import-dependent), so callers who want the native,
+ * overlay-definition-driven layer list register it explicitly:
+ *
+ * ```ts
+ * import { defineHonuaLayerList } from "@honua/sdk-js/controls";
+ * defineHonuaLayerList();
+ * ```
+ */
+export function defineHonuaLayerList(registry = globalDom.customElements) {
+    if (!registry)
+        return;
+    if (!registry.get("honua-layer-list")) {
+        registry.define("honua-layer-list", HonuaLayerListElement);
+    }
+}
+function normalizeOverlays(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((item) => {
+        if (!item || typeof item !== "object")
+            return [];
+        const candidate = item;
+        if (typeof candidate.id !== "string" || typeof candidate.label !== "string")
+            return [];
+        const layers = Array.isArray(candidate.layers)
+            ? candidate.layers.filter((layer) => typeof layer === "string")
+            : [];
+        return [
+            {
+                id: candidate.id,
+                label: candidate.label,
+                layers,
+                ...(typeof candidate.attribution === "string" ? { attribution: candidate.attribution } : {}),
+            },
+        ];
+    });
+}
+function parseOverlays(value) {
+    if (!value)
+        return undefined;
+    try {
+        const parsed = JSON.parse(value);
+        if (!Array.isArray(parsed))
+            return undefined;
+        return normalizeOverlays(parsed);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Minimal CSS identifier escape for the attribute selector in `#syncRow`. */
+function cssEscape(value) {
+    return value.replace(/["\\]/g, "\\$&");
+}
+/** Structural-only styles; theme via `::part(root)`, `::part(row)`, `::part(checkbox)`, ... */
+function structuralStyles() {
+    return `
+    :host { display: block; }
+    .root { display: flex; flex-direction: column; }
+    .row { display: flex; align-items: center; gap: 0.5em; }
+    .checkbox { flex: none; }
+    .badge { font-size: 0.75em; }
+    [data-not-seeded] { cursor: not-allowed; }
+  `;
+}

package/controls/legend-derive.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Derive-mode engine behind `<honua-legend>`: parses a style layer's
+ * categorical color paint expression into legend entries, so the map style
+ * stays the single source of truth and the legend cannot drift from it.
+ *
+ * ## Supported expression shapes
+ *
+ * The color paint property of the layer (`fill-color`, `line-color`, or
+ * `circle-color` depending on the layer type) may be:
+ *
+ * 1. A literal CSS color string — yields a single entry labeled with the
+ *    layer id.
+ * 2. `["match", ["get", <attr>], in1, color1, ..., fallbackColor]` — the
+ *    primary categorical shape. Branch inputs may be strings, numbers, or
+ *    arrays thereof (an array branch becomes one row labeled with the values
+ *    joined by `", "`). Every output, including the fallback, must be a
+ *    literal color string; the fallback becomes a row labeled `"Other"`.
+ * 3. `["case", ["==", ["get", <attr>], <literal>], color1, ..., fallback]` —
+ *    simple equality chains only; each condition labels its row with the
+ *    compared literal, and the fallback becomes `"Other"`.
+ * 4. `["step", ["get", <attr>], color0, stop1, color1, ...]` — numeric breaks
+ *    on a feature attribute, labeled `"< stop1"`, `"stop1–stop2"`, ...,
+ *    `"≥ stopN"`.
+ *
+ * Anything else — `interpolate`, zoom- or feature-state-driven expressions,
+ * non-literal color outputs, nested expressions, unsupported layer types —
+ * throws {@link HonuaLegendDeriveError} with a `code` describing the failure,
+ * so callers can fall back gracefully instead of rendering a wrong legend.
+ *
+ * For `fill` layers, a literal `fill-outline-color` is propagated to every
+ * derived entry as the swatch outline.
+ *
+ * @module
+ */
+import type { HonuaLegendEntry, HonuaLegendMap } from "./types.js";
+/** Machine-readable reason a legend could not be derived. */
+export type HonuaLegendDeriveErrorCode = "layer-not-found" | "unsupported-layer-type" | "missing-paint" | "unsupported-expression";
+/** Thrown by {@link deriveLegendEntries} when a legend cannot be derived. */
+export declare class HonuaLegendDeriveError extends Error {
+    readonly name = "HonuaLegendDeriveError";
+    /** Why derivation failed; `"layer-not-found"` is often transient (layer not added yet). */
+    readonly code: HonuaLegendDeriveErrorCode;
+    constructor(code: HonuaLegendDeriveErrorCode, message: string);
+}
+/** Label given to the `match`/`case` fallback branch. */
+export declare const HONUA_LEGEND_FALLBACK_LABEL = "Other";
+/**
+ * Derives legend entries from the categorical color expression of the given
+ * style layer. See the module docs for the supported expression shapes;
+ * throws {@link HonuaLegendDeriveError} on anything else.
+ */
+export declare function deriveLegendEntries(map: HonuaLegendMap, layerId: string): HonuaLegendEntry[];
+//# sourceMappingURL=legend-derive.d.ts.map

package/controls/legend-derive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"legend-derive.d.ts","sourceRoot":"","sources":["../../../src/controls/legend-derive.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAA0B,MAAM,YAAY,CAAC;AAE3F,6DAA6D;AAC7D,MAAM,MAAM,0BAA0B,GAClC,iBAAiB,GACjB,wBAAwB,GACxB,eAAe,GACf,wBAAwB,CAAC;AAE7B,6EAA6E;AAC7E,qBAAa,sBAAuB,SAAQ,KAAK;IAC/C,SAAyB,IAAI,4BAA4B;IACzD,2FAA2F;IAC3F,SAAgB,IAAI,EAAE,0BAA0B,CAAC;gBAE9B,IAAI,EAAE,0BAA0B,EAAE,OAAO,EAAE,MAAM;CAIrE;AAQD,yDAAyD;AACzD,eAAO,MAAM,2BAA2B,UAAU,CAAC;AAEnD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,GAAG,gBAAgB,EAAE,CAuB5F"}

package/controls/legend-derive.js

@@ -0,0 +1,196 @@
+/**
+ * Derive-mode engine behind `<honua-legend>`: parses a style layer's
+ * categorical color paint expression into legend entries, so the map style
+ * stays the single source of truth and the legend cannot drift from it.
+ *
+ * ## Supported expression shapes
+ *
+ * The color paint property of the layer (`fill-color`, `line-color`, or
+ * `circle-color` depending on the layer type) may be:
+ *
+ * 1. A literal CSS color string — yields a single entry labeled with the
+ *    layer id.
+ * 2. `["match", ["get", <attr>], in1, color1, ..., fallbackColor]` — the
+ *    primary categorical shape. Branch inputs may be strings, numbers, or
+ *    arrays thereof (an array branch becomes one row labeled with the values
+ *    joined by `", "`). Every output, including the fallback, must be a
+ *    literal color string; the fallback becomes a row labeled `"Other"`.
+ * 3. `["case", ["==", ["get", <attr>], <literal>], color1, ..., fallback]` —
+ *    simple equality chains only; each condition labels its row with the
+ *    compared literal, and the fallback becomes `"Other"`.
+ * 4. `["step", ["get", <attr>], color0, stop1, color1, ...]` — numeric breaks
+ *    on a feature attribute, labeled `"< stop1"`, `"stop1–stop2"`, ...,
+ *    `"≥ stopN"`.
+ *
+ * Anything else — `interpolate`, zoom- or feature-state-driven expressions,
+ * non-literal color outputs, nested expressions, unsupported layer types —
+ * throws {@link HonuaLegendDeriveError} with a `code` describing the failure,
+ * so callers can fall back gracefully instead of rendering a wrong legend.
+ *
+ * For `fill` layers, a literal `fill-outline-color` is propagated to every
+ * derived entry as the swatch outline.
+ *
+ * @module
+ */
+/** Thrown by {@link deriveLegendEntries} when a legend cannot be derived. */
+export class HonuaLegendDeriveError extends Error {
+    name = "HonuaLegendDeriveError";
+    /** Why derivation failed; `"layer-not-found"` is often transient (layer not added yet). */
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+const PAINT_BY_LAYER_TYPE = {
+    fill: { property: "fill-color", shape: "fill" },
+    line: { property: "line-color", shape: "line" },
+    circle: { property: "circle-color", shape: "circle" },
+};
+/** Label given to the `match`/`case` fallback branch. */
+export const HONUA_LEGEND_FALLBACK_LABEL = "Other";
+/**
+ * Derives legend entries from the categorical color expression of the given
+ * style layer. See the module docs for the supported expression shapes;
+ * throws {@link HonuaLegendDeriveError} on anything else.
+ */
+export function deriveLegendEntries(map, layerId) {
+    const layer = typeof map.getLayer === "function" ? map.getLayer(layerId) : undefined;
+    if (!layer || typeof layer !== "object") {
+        throw new HonuaLegendDeriveError("layer-not-found", `Layer "${layerId}" does not exist on the map.`);
+    }
+    const layerType = layer.type;
+    const mapping = typeof layerType === "string" ? PAINT_BY_LAYER_TYPE[layerType] : undefined;
+    if (!mapping) {
+        throw new HonuaLegendDeriveError("unsupported-layer-type", `Cannot derive a legend for layer "${layerId}" of type "${String(layerType)}"; supported types: fill, line, circle.`);
+    }
+    const value = readPaintProperty(map, layer, layerId, mapping.property);
+    if (value === undefined || value === null) {
+        throw new HonuaLegendDeriveError("missing-paint", `Layer "${layerId}" has no "${mapping.property}" paint value to derive a legend from.`);
+    }
+    const outline = mapping.shape === "fill" ? literalColor(readPaintProperty(map, layer, layerId, "fill-outline-color")) : undefined;
+    return colorValueToEntries(value, layerId, mapping.shape, outline);
+}
+function readPaintProperty(map, layer, layerId, name) {
+    if (typeof map.getPaintProperty === "function") {
+        const value = map.getPaintProperty(layerId, name);
+        if (value !== undefined)
+            return value;
+    }
+    const paint = layer.paint;
+    if (typeof paint === "object" && paint !== null)
+        return paint[name];
+    return undefined;
+}
+function colorValueToEntries(value, layerId, shape, outline) {
+    if (typeof value === "string")
+        return [makeEntry(layerId, value, shape, outline)];
+    if (Array.isArray(value)) {
+        const operator = value[0];
+        if (operator === "match")
+            return matchToEntries(value, layerId, shape, outline);
+        if (operator === "case")
+            return caseToEntries(value, layerId, shape, outline);
+        if (operator === "step")
+            return stepToEntries(value, layerId, shape, outline);
+        throw new HonuaLegendDeriveError("unsupported-expression", `Layer "${layerId}": unsupported color expression operator "${String(operator)}"; supported: literal color, match, case, step.`);
+    }
+    throw new HonuaLegendDeriveError("unsupported-expression", `Layer "${layerId}": color paint value must be a literal color string or a match/case/step expression.`);
+}
+function matchToEntries(expression, layerId, shape, outline) {
+    requireGetInput(expression[1], layerId, "match");
+    const body = expression.slice(2);
+    if (body.length < 3 || body.length % 2 === 0) {
+        throw new HonuaLegendDeriveError("unsupported-expression", `Layer "${layerId}": match expression must have branch input/output pairs plus a fallback color.`);
+    }
+    const entries = [];
+    for (let index = 0; index < body.length - 1; index += 2) {
+        const label = matchBranchLabel(body[index], layerId);
+        const color = requireLiteralColor(body[index + 1], layerId);
+        entries.push(makeEntry(label, color, shape, outline));
+    }
+    entries.push(makeEntry(HONUA_LEGEND_FALLBACK_LABEL, requireLiteralColor(body[body.length - 1], layerId), shape, outline));
+    return entries;
+}
+function matchBranchLabel(input, layerId) {
+    if (typeof input === "string" || typeof input === "number")
+        return String(input);
+    if (Array.isArray(input) &&
+        input.length > 0 &&
+        input.every((item) => typeof item === "string" || typeof item === "number")) {
+        return input.map((item) => String(item)).join(", ");
+    }
+    throw new HonuaLegendDeriveError("unsupported-expression", `Layer "${layerId}": match branch inputs must be strings, numbers, or arrays of them.`);
+}
+function caseToEntries(expression, layerId, shape, outline) {
+    const body = expression.slice(1);
+    if (body.length < 3 || body.length % 2 === 0) {
+        throw new HonuaLegendDeriveError("unsupported-expression", `Layer "${layerId}": case expression must have condition/output pairs plus a fallback color.`);
+    }
+    const entries = [];
+    for (let index = 0; index < body.length - 1; index += 2) {
+        const label = caseConditionLabel(body[index], layerId);
+        const color = requireLiteralColor(body[index + 1], layerId);
+        entries.push(makeEntry(label, color, shape, outline));
+    }
+    entries.push(makeEntry(HONUA_LEGEND_FALLBACK_LABEL, requireLiteralColor(body[body.length - 1], layerId), shape, outline));
+    return entries;
+}
+function caseConditionLabel(condition, layerId) {
+    if (Array.isArray(condition) && condition.length === 3 && condition[0] === "==") {
+        const compared = condition[2];
+        if (isGetExpression(condition[1]) &&
+            (typeof compared === "string" || typeof compared === "number" || typeof compared === "boolean")) {
+            return String(compared);
+        }
+    }
+    throw new HonuaLegendDeriveError("unsupported-expression", `Layer "${layerId}": case conditions must be simple equalities ["==", ["get", <attribute>], <literal>].`);
+}
+function stepToEntries(expression, layerId, shape, outline) {
+    requireGetInput(expression[1], layerId, "step");
+    const body = expression.slice(2);
+    if (body.length < 3 || body.length % 2 === 0) {
+        throw new HonuaLegendDeriveError("unsupported-expression", `Layer "${layerId}": step expression must have a base color plus stop/color pairs.`);
+    }
+    const stops = [];
+    const colors = [requireLiteralColor(body[0], layerId)];
+    for (let index = 1; index < body.length; index += 2) {
+        const stop = body[index];
+        if (typeof stop !== "number") {
+            throw new HonuaLegendDeriveError("unsupported-expression", `Layer "${layerId}": step stops must be numeric literals.`);
+        }
+        stops.push(stop);
+        colors.push(requireLiteralColor(body[index + 1], layerId));
+    }
+    return colors.map((color, index) => {
+        const lower = index === 0 ? undefined : stops[index - 1];
+        const upper = index < stops.length ? stops[index] : undefined;
+        const label = lower === undefined
+            ? `< ${String(upper)}`
+            : upper === undefined
+                ? `≥ ${String(lower)}`
+                : `${String(lower)}–${String(upper)}`;
+        return makeEntry(label, color, shape, outline);
+    });
+}
+function requireGetInput(input, layerId, operator) {
+    if (!isGetExpression(input)) {
+        throw new HonuaLegendDeriveError("unsupported-expression", `Layer "${layerId}": ${operator} input must be a ["get", <attribute>] expression on a feature attribute.`);
+    }
+}
+function isGetExpression(value) {
+    return Array.isArray(value) && value[0] === "get" && typeof value[1] === "string";
+}
+function requireLiteralColor(value, layerId) {
+    const color = literalColor(value);
+    if (color === undefined) {
+        throw new HonuaLegendDeriveError("unsupported-expression", `Layer "${layerId}": expression outputs must be literal color strings; got ${JSON.stringify(value)}.`);
+    }
+    return color;
+}
+function literalColor(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function makeEntry(label, fill, shape, outline) {
+    return { label, color: outline === undefined ? fill : { fill, outline }, shape };
+}