@honua/app-platform 0.1.11-beta.0 → 0.1.13

package/web-components/map-chrome.js

@@ -0,0 +1,325 @@
+/**
+ * Map chrome that wraps a MapLibre control, or a home button that returns
+ * to the viewpoint stored on the compat shim.
+ */
+import { AttributionControl, FullscreenControl, NavigationControl, ScaleControl, } from "maplibre-gl";
+const HTMLElementBase = globalThis.HTMLElement ?? class {
+};
+function labelOf(element, fallback) {
+    return element.getAttribute("label") ?? fallback;
+}
+class HonuaChromeElement extends HTMLElementBase {
+    #map;
+    #view;
+    #control;
+    get map() {
+        return this.#map;
+    }
+    set map(map) {
+        this.#map = map;
+        this.render();
+    }
+    get view() {
+        return this.#view;
+    }
+    set view(view) {
+        this.#view = view;
+        this.render();
+    }
+    /** Compat view pushed by the host. A MapLibre map is not a view. */
+    compatView() {
+        if (isCompatView(this.#view))
+            return this.#view;
+        if (isCompatView(this.#map))
+            return this.#map;
+        return undefined;
+    }
+    connectedCallback() {
+        if (!this.shadowRoot)
+            this.attachShadow({ mode: "open" });
+        this.render();
+    }
+    attributeChangedCallback() {
+        this.render();
+    }
+    /** Control chrome wired to the compat view when no MapLibre map is mounted. */
+    renderCompat(_section) { }
+    render() {
+        if (!this.shadowRoot)
+            return;
+        const label = labelOf(this, this.fallback());
+        this.shadowRoot.innerHTML = `<section aria-label="${escapeAttr(label)}"><slot></slot></section>`;
+        const section = this.shadowRoot.querySelector("section");
+        if (!section)
+            return;
+        try {
+            this.#control?.onRemove(this.#map);
+        }
+        catch {
+            // A control that failed onAdd can still be replaced on the next render.
+        }
+        const control = this.control();
+        this.#control = control;
+        if (control && isMapLibreMap(this.#map)) {
+            try {
+                section.append(control.onAdd(this.#map));
+                return;
+            }
+            catch {
+                // The MapLibre control rejected this map. The compat view still gets a control.
+            }
+        }
+        this.renderCompat(section);
+    }
+}
+function isMapLibreMap(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const map = value;
+    return (typeof map.getCanvas === "function" &&
+        typeof map.getContainer === "function" &&
+        typeof map.zoomIn === "function" &&
+        typeof map._getUIString === "function");
+}
+function isCompatView(value) {
+    return !!value && typeof value === "object" && !isMapLibreMap(value);
+}
+function escapeAttr(value) {
+    return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;");
+}
+function escapeText(value) {
+    return escapeAttr(value);
+}
+export class HonuaZoomElement extends HonuaChromeElement {
+    static get observedAttributes() {
+        return ["label"];
+    }
+    fallback() {
+        return "Zoom";
+    }
+    control() {
+        if (this.compatView() || !isMapLibreMap(this.map))
+            return undefined;
+        return new NavigationControl({ showCompass: false, showZoom: true });
+    }
+    renderCompat(section) {
+        const group = document.createElement("div");
+        group.className = "maplibregl-ctrl maplibregl-ctrl-group";
+        group.append(this.zoomButton("maplibregl-ctrl-zoom-in", "Zoom in", 1), this.zoomButton("maplibregl-ctrl-zoom-out", "Zoom out", -1));
+        section.append(group);
+    }
+    zoomButton(className, label, delta) {
+        const button = document.createElement("button");
+        button.type = "button";
+        button.className = className;
+        button.setAttribute("aria-label", label);
+        const icon = document.createElement("span");
+        icon.className = "maplibregl-ctrl-icon";
+        icon.setAttribute("aria-hidden", "true");
+        button.append(icon);
+        button.addEventListener("click", () => this.step(delta));
+        return button;
+    }
+    step(delta) {
+        const view = this.compatView();
+        if (!view)
+            return;
+        const current = typeof view.zoom === "number" && Number.isFinite(view.zoom) ? view.zoom : 2;
+        const next = current + delta;
+        view.zoom = next;
+        if (typeof view.goTo === "function")
+            void view.goTo.call(view, { zoom: next });
+    }
+}
+export class HonuaScaleBarElement extends HonuaChromeElement {
+    static get observedAttributes() {
+        return ["label"];
+    }
+    #text = "";
+    #unit = "metric";
+    get text() {
+        return this.#text;
+    }
+    set text(text) {
+        this.#text = text ?? "";
+        this.render();
+    }
+    get unit() {
+        return this.#unit;
+    }
+    set unit(unit) {
+        this.#unit = unit ?? "metric";
+        this.render();
+    }
+    fallback() {
+        return "Scale";
+    }
+    control() {
+        if (this.compatView() || this.#text.trim() || !isMapLibreMap(this.map))
+            return undefined;
+        const unit = this.#unit === "imperial" || this.#unit === "nautical" ? this.#unit : "metric";
+        return new ScaleControl({ maxWidth: 80, unit });
+    }
+    renderCompat(section) {
+        const node = document.createElement("div");
+        node.className = "maplibregl-ctrl maplibregl-ctrl-scale";
+        node.textContent = this.scaleLabel();
+        section.append(node);
+    }
+    scaleLabel() {
+        if (this.#text.trim())
+            return this.#text;
+        const zoom = this.compatView()?.zoom;
+        if (typeof zoom !== "number" || !Number.isFinite(zoom))
+            return "";
+        return formatScaleBar(zoom, this.#unit);
+    }
+}
+export class HonuaFullscreenElement extends HonuaChromeElement {
+    static get observedAttributes() {
+        return ["label"];
+    }
+    fallback() {
+        return "Fullscreen";
+    }
+    control() {
+        if (this.compatView() || !isMapLibreMap(this.map))
+            return undefined;
+        return new FullscreenControl();
+    }
+    renderCompat(section) {
+        const button = document.createElement("button");
+        button.type = "button";
+        button.className = "maplibregl-ctrl-fullscreen";
+        button.textContent = labelOf(this, "Fullscreen");
+        button.addEventListener("click", () => {
+            const container = this.compatView()?.container;
+            const target = container instanceof HTMLElement ? container : this.ownerDocument?.documentElement;
+            const request = target?.requestFullscreen;
+            if (typeof request === "function")
+                void request.call(target);
+        });
+        section.append(button);
+    }
+}
+export class HonuaAttributionElement extends HonuaChromeElement {
+    static get observedAttributes() {
+        return ["label"];
+    }
+    #attributions = [];
+    get attributions() {
+        return this.#attributions;
+    }
+    set attributions(attributions) {
+        this.#attributions = attributions ?? [];
+        this.render();
+    }
+    fallback() {
+        return "Attribution";
+    }
+    control() {
+        if (!isMapLibreMap(this.map))
+            return undefined;
+        return new AttributionControl({ compact: false, customAttribution: this.#attributions.join(" | ") });
+    }
+    renderCompat(section) {
+        const node = document.createElement("div");
+        node.className = "maplibregl-ctrl maplibregl-ctrl-attrib";
+        node.textContent = this.#attributions.join(" | ");
+        section.append(node);
+    }
+}
+export class HonuaCompassElement extends HTMLElementBase {
+    static get observedAttributes() {
+        return ["label"];
+    }
+    #view;
+    get view() {
+        return this.#view;
+    }
+    set view(view) {
+        this.#view = view;
+        this.render();
+    }
+    connectedCallback() {
+        if (!this.shadowRoot)
+            this.attachShadow({ mode: "open" });
+        this.render();
+    }
+    attributeChangedCallback() {
+        this.render();
+    }
+    reset() {
+        if (this.#view)
+            this.#view.rotation = 0;
+        void this.#view?.goTo?.({ rotation: 0 });
+        this.render();
+    }
+    render() {
+        if (!this.shadowRoot)
+            return;
+        const label = labelOf(this, "Compass");
+        this.shadowRoot.innerHTML = `<section aria-label="${escapeAttr(label)}"><button type="button" class="maplibregl-ctrl-compass">${escapeText(label)}</button></section>`;
+        this.shadowRoot.querySelector("button")?.addEventListener("click", () => this.reset());
+    }
+}
+export class HonuaHomeElement extends HTMLElementBase {
+    static get observedAttributes() {
+        return ["label"];
+    }
+    #view;
+    #viewpoint;
+    get view() {
+        return this.#view;
+    }
+    set view(view) {
+        this.#view = view;
+    }
+    get viewpoint() {
+        return this.#viewpoint;
+    }
+    set viewpoint(viewpoint) {
+        this.#viewpoint = viewpoint;
+        this.render();
+    }
+    connectedCallback() {
+        if (!this.shadowRoot)
+            this.attachShadow({ mode: "open" });
+        this.render();
+    }
+    attributeChangedCallback() {
+        this.render();
+    }
+    go() {
+        const target = { center: this.#viewpoint?.center, zoom: this.#viewpoint?.zoom };
+        void this.#view?.goTo?.(target);
+    }
+    render() {
+        if (!this.shadowRoot)
+            return;
+        const label = labelOf(this, "Home");
+        this.shadowRoot.innerHTML = `<section aria-label="${escapeAttr(label)}"><button type="button" class="maplibregl-ctrl-home">${escapeText(label)}</button></section>`;
+        this.shadowRoot.querySelector("button")?.addEventListener("click", () => this.go());
+    }
+}
+function formatScaleBar(zoom, unit) {
+    const scale = 591657527.591555 / 2 ** zoom;
+    const ratioText = `1:${Math.max(1, Math.round(scale)).toLocaleString("en-US")}`;
+    if (unit === "imperial")
+        return `${ratioText} | ${formatImperialDistance(scale)}`;
+    if (unit === "dual")
+        return `${ratioText} | ${formatMetricDistance(scale)} / ${formatImperialDistance(scale)}`;
+    return `${ratioText} | ${formatMetricDistance(scale)}`;
+}
+function formatMetricDistance(scale) {
+    const meters = Math.max(1, Math.round(scale * 0.00028));
+    if (meters >= 1000)
+        return `${Math.round(meters / 1000)} km`;
+    return `${meters} m`;
+}
+function formatImperialDistance(scale) {
+    const feet = Math.max(1, Math.round(scale * 0.0009186351706));
+    if (feet >= 5280)
+        return `${Math.round(feet / 5280)} mi`;
+    return `${feet} ft`;
+}

package/web-components/widget-shell.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Feature pager, attachments list, scale range, and route directions.
+ * These render fixture data. They do not upload attachments, edit travel
+ * modes, or invent route maneuvers.
+ */
+declare const HTMLElementBase: typeof HTMLElement;
+interface PagerFeature {
+    title?: string;
+    attributes?: Record<string, unknown>;
+}
+export declare class HonuaFeaturePagerElement extends HTMLElementBase {
+    #private;
+    static get observedAttributes(): string[];
+    get features(): readonly PagerFeature[];
+    set features(features: readonly PagerFeature[] | undefined);
+    get index(): number;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(): void;
+    next(): void;
+    private render;
+}
+export declare class HonuaAttachmentsElement extends HTMLElementBase {
+    #private;
+    static get observedAttributes(): string[];
+    get names(): readonly string[];
+    set names(names: readonly string[] | undefined);
+    connectedCallback(): void;
+    attributeChangedCallback(): void;
+    private render;
+}
+export declare class HonuaScaleRangeElement extends HTMLElementBase {
+    #private;
+    static get observedAttributes(): string[];
+    get layer(): {
+        minScale?: number;
+        maxScale?: number;
+        setScaleRange?: (min: number, max: number) => void;
+    } | undefined;
+    set layer(layer: {
+        minScale?: number;
+        maxScale?: number;
+        setScaleRange?: (min: number, max: number) => void;
+    } | undefined);
+    connectedCallback(): void;
+    attributeChangedCallback(): void;
+    setRange(minScale: number, maxScale: number): void;
+    private render;
+}
+export interface DirectionsRouteLike {
+    summary?: string;
+    steps?: readonly {
+        text?: string;
+        maneuver?: string;
+    }[];
+    polyline?: unknown;
+}
+export declare class HonuaDirectionsElement extends HTMLElementBase {
+    #private;
+    static get observedAttributes(): string[];
+    get route(): DirectionsRouteLike | undefined;
+    set route(route: DirectionsRouteLike | undefined);
+    connectedCallback(): void;
+    attributeChangedCallback(): void;
+    private render;
+}
+export {};
+//# sourceMappingURL=widget-shell.d.ts.map

package/web-components/widget-shell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"widget-shell.d.ts","sourceRoot":"","sources":["../../../src/web-components/widget-shell.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAUH,QAAA,MAAM,eAAe,EAAE,OAAO,WACmF,CAAC;AAIlH,UAAU,YAAY;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC;AAaD,qBAAa,wBAAyB,SAAQ,eAAe;;IAC3D,WAAkB,kBAAkB,IAAI,MAAM,EAAE,CAE/C;IAMD,IAAW,QAAQ,IAAI,SAAS,YAAY,EAAE,CAE7C;IAED,IAAW,QAAQ,CAAC,QAAQ,EAAE,SAAS,YAAY,EAAE,GAAG,SAAS,EAIhE;IAED,IAAW,KAAK,IAAI,MAAM,CAEzB;IAEM,iBAAiB,IAAI,IAAI;IAIzB,oBAAoB,IAAI,IAAI;IAI5B,wBAAwB,IAAI,IAAI;IAIhC,IAAI,IAAI,IAAI;IAYnB,OAAO,CAAC,MAAM;CAqCf;AAiCD,qBAAa,uBAAwB,SAAQ,eAAe;;IAC1D,WAAkB,kBAAkB,IAAI,MAAM,EAAE,CAE/C;IAID,IAAW,KAAK,IAAI,SAAS,MAAM,EAAE,CAEpC;IAED,IAAW,KAAK,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,EAGpD;IAEM,iBAAiB,IAAI,IAAI;IAIzB,wBAAwB,IAAI,IAAI;IAIvC,OAAO,CAAC,MAAM;CAKf;AAED,qBAAa,sBAAuB,SAAQ,eAAe;;IACzD,WAAkB,kBAAkB,IAAI,MAAM,EAAE,CAE/C;IAMD,IAAW,KAAK,IACZ;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE,GAC5F,SAAS,CAEZ;IAED,IAAW,KAAK,CAAC,KAAK,EAClB;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE,GAC5F,SAAS,EAKZ;IAEM,iBAAiB,IAAI,IAAI;IAIzB,wBAAwB,IAAI,IAAI;IAIhC,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAWzD,OAAO,CAAC,MAAM;CAef;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,SAAS;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACxD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,qBAAa,sBAAuB,SAAQ,eAAe;;IACzD,WAAkB,kBAAkB,IAAI,MAAM,EAAE,CAE/C;IAID,IAAW,KAAK,IAAI,mBAAmB,GAAG,SAAS,CAElD;IAED,IAAW,KAAK,CAAC,KAAK,EAAE,mBAAmB,GAAG,SAAS,EAGtD;IAEM,iBAAiB,IAAI,IAAI;IAIzB,wBAAwB,IAAI,IAAI;IAIvC,OAAO,CAAC,MAAM;CAYf"}

package/web-components/widget-shell.js

@@ -0,0 +1,224 @@
+/**
+ * Feature pager, attachments list, scale range, and route directions.
+ * These render fixture data. They do not upload attachments, edit travel
+ * modes, or invent route maneuvers.
+ */
+import { capabilities } from "../contract/types.js";
+import { sourceFeatureSelectionTarget } from "../exploration/selection.js";
+import { createHonuaFeatureInspection, } from "./feature-inspection.js";
+const HTMLElementBase = globalThis.HTMLElement ?? class {
+};
+const PAGER_SOURCE_ID = "honua-widget-shell-features";
+function escapeText(value) {
+    return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll('"', "&quot;");
+}
+function section(element, label, body) {
+    if (!element.shadowRoot)
+        element.attachShadow({ mode: "open" });
+    const shadow = element.shadowRoot;
+    if (!shadow)
+        return;
+    shadow.innerHTML = `<section aria-label="${escapeText(label)}">${body}</section>`;
+}
+export class HonuaFeaturePagerElement extends HTMLElementBase {
+    static get observedAttributes() {
+        return ["label"];
+    }
+    #features = [];
+    #index = 0;
+    #controllers = [];
+    get features() {
+        return this.#features;
+    }
+    set features(features) {
+        this.#features = features ?? [];
+        this.#index = 0;
+        this.render();
+    }
+    get index() {
+        return this.#index;
+    }
+    connectedCallback() {
+        this.render();
+    }
+    disconnectedCallback() {
+        this.#releaseControllers();
+    }
+    attributeChangedCallback() {
+        this.render();
+    }
+    next() {
+        if (this.#features.length === 0)
+            return;
+        this.#index = (this.#index + 1) % this.#features.length;
+        this.render();
+    }
+    #releaseControllers() {
+        const controllers = this.#controllers;
+        this.#controllers = [];
+        for (const controller of controllers)
+            controller.dispose();
+    }
+    render() {
+        this.#releaseControllers();
+        const label = this.getAttribute("label") ?? "Features";
+        const pages = this.#features
+            .map((_, index) => {
+            const hidden = index === this.#index ? "" : " hidden";
+            return `<div data-feature-page="${index}"${hidden}><honua-feature-inspection data-page="${index}"></honua-feature-inspection></div>`;
+        })
+            .join("");
+        section(this, label, `<p>${this.#features.length === 0 ? "0" : this.#index + 1} / ${this.#features.length}</p>${pages}<button type="button" data-next>Next</button>`);
+        this.#features.forEach((feature, index) => {
+            const inspection = this.shadowRoot?.querySelector(`honua-feature-inspection[data-page="${index}"]`);
+            if (!inspection || !("inspection" in inspection))
+                return;
+            const attributes = inspectionAttributes(feature, index);
+            const source = pagerSource(attributes);
+            const controller = createHonuaFeatureInspection({
+                resolveSource: (sourceId) => (sourceId === PAGER_SOURCE_ID ? source : undefined),
+                presentation: { titleField: "name", fields: Object.keys(attributes) },
+                loadAttachmentPage: async () => ({ items: [], total: 0 }),
+            });
+            this.#controllers.push(controller);
+            inspection.inspection = controller;
+            const id = featureId(attributes, index);
+            void controller.open({
+                target: sourceFeatureSelectionTarget(PAGER_SOURCE_ID, id),
+                feature: { attributes },
+                authoritative: true,
+            });
+        });
+        this.shadowRoot?.querySelector("[data-next]")?.addEventListener("click", () => this.next());
+    }
+}
+function inspectionAttributes(feature, index) {
+    const attributes = { ...(feature.attributes ?? {}) };
+    const named = typeof attributes.name === "string" && attributes.name.trim() ? attributes.name : undefined;
+    const titled = typeof attributes.title === "string" && attributes.title.trim() ? attributes.title : undefined;
+    const title = feature.title?.trim() || named || titled || `Feature ${index + 1}`;
+    attributes.name = title;
+    if (!("OBJECTID" in attributes))
+        attributes.OBJECTID = index + 1;
+    return attributes;
+}
+function featureId(attributes, index) {
+    const objectId = attributes.OBJECTID;
+    if (typeof objectId === "string" || typeof objectId === "number")
+        return objectId;
+    return index + 1;
+}
+function pagerSource(attributes) {
+    const fields = Object.keys(attributes).map((name) => ({ name, alias: name, type: "esriFieldTypeString" }));
+    const advertised = capabilities(["query", "attachments"]);
+    return {
+        descriptor: {
+            id: PAGER_SOURCE_ID,
+            protocol: "geoservices-feature-service",
+            locator: { url: "https://widgets.honua.invalid/features" },
+            capabilities: advertised,
+            schema: { primaryKey: "OBJECTID", fields },
+        },
+        capabilities: advertised,
+    };
+}
+export class HonuaAttachmentsElement extends HTMLElementBase {
+    static get observedAttributes() {
+        return ["label"];
+    }
+    #names = [];
+    get names() {
+        return this.#names;
+    }
+    set names(names) {
+        this.#names = names ?? [];
+        this.render();
+    }
+    connectedCallback() {
+        this.render();
+    }
+    attributeChangedCallback() {
+        this.render();
+    }
+    render() {
+        const label = this.getAttribute("label") ?? "Attachments";
+        const items = this.#names.map((name) => `<li>${escapeText(name)}</li>`).join("");
+        section(this, label, `<ul>${items}</ul>`);
+    }
+}
+export class HonuaScaleRangeElement extends HTMLElementBase {
+    static get observedAttributes() {
+        return ["label"];
+    }
+    #layer;
+    #min = 0;
+    #max = 0;
+    get layer() {
+        return this.#layer;
+    }
+    set layer(layer) {
+        this.#layer = layer;
+        this.#min = layer?.minScale ?? 0;
+        this.#max = layer?.maxScale ?? 0;
+        this.render();
+    }
+    connectedCallback() {
+        this.render();
+    }
+    attributeChangedCallback() {
+        this.render();
+    }
+    setRange(minScale, maxScale) {
+        this.#min = minScale;
+        this.#max = maxScale;
+        if (this.#layer?.setScaleRange)
+            this.#layer.setScaleRange(minScale, maxScale);
+        else if (this.#layer) {
+            this.#layer.minScale = minScale;
+            this.#layer.maxScale = maxScale;
+        }
+        this.render();
+    }
+    render() {
+        const label = this.getAttribute("label") ?? "Scale range";
+        section(this, label, `<label>Min <input data-min type="number" value="${this.#min}" /></label><label>Max <input data-max type="number" value="${this.#max}" /></label>`);
+        const commit = () => {
+            const min = Number(this.shadowRoot?.querySelector("[data-min]")?.value);
+            const max = Number(this.shadowRoot?.querySelector("[data-max]")?.value);
+            if (Number.isFinite(min) && Number.isFinite(max))
+                this.setRange(min, max);
+        };
+        this.shadowRoot?.querySelector("[data-min]")?.addEventListener("change", commit);
+        this.shadowRoot?.querySelector("[data-max]")?.addEventListener("change", commit);
+    }
+}
+export class HonuaDirectionsElement extends HTMLElementBase {
+    static get observedAttributes() {
+        return ["label"];
+    }
+    #route;
+    get route() {
+        return this.#route;
+    }
+    set route(route) {
+        this.#route = route;
+        this.render();
+    }
+    connectedCallback() {
+        this.render();
+    }
+    attributeChangedCallback() {
+        this.render();
+    }
+    render() {
+        const label = this.getAttribute("label") ?? "Directions";
+        const steps = (this.#route?.steps ?? [])
+            .map((step) => step.text ?? step.maneuver)
+            .filter((text) => Boolean(text));
+        const summary = this.#route?.summary ?? "";
+        const body = steps.length > 0
+            ? `<p>${escapeText(summary)}</p><ol>${steps.map((step) => `<li>${escapeText(step)}</li>`).join("")}</ol>`
+            : `<p>${escapeText(summary)}</p>`;
+        section(this, label, body);
+    }
+}

package/widget-capabilities.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Pure helpers behind sketch snapping, histogram bins, form expressions,
+ * multi-feature edits, and elevation samples.
+ */
+export interface SnapPoint {
+    x: number;
+    y: number;
+}
+export declare function snapVertex(pointer: SnapPoint, vertices: readonly SnapPoint[], enabled: boolean, tolerance?: number): SnapPoint;
+export interface HistogramStats {
+    count: number;
+    sum: number;
+    min: number;
+    max: number;
+    average: number;
+}
+export interface HistogramBin {
+    label: string;
+    min: number;
+    max: number;
+    value: number;
+}
+export declare function histogramBins(values: readonly number[], stats: HistogramStats, classes: number, method: "equal-interval" | "quantile"): HistogramBin[];
+export declare function histogramRangeFilter(min: number, max: number): string;
+export interface FormExpressionField {
+    name: string;
+    visibleExpression?: string;
+    valueExpression?: string;
+}
+export interface FormExpressionResult {
+    hidden: string[];
+    values: Record<string, unknown>;
+    errors: {
+        field: string;
+        message: string;
+    }[];
+}
+export declare function evaluateFormExpressions(fields: readonly FormExpressionField[], feature: {
+    attributes?: Record<string, unknown>;
+}): FormExpressionResult;
+export interface FeatureEdit {
+    attributes?: Record<string, unknown>;
+}
+export interface ApplyEditsResult {
+    error?: string;
+    reason?: string;
+}
+export declare function applyToFeatures(features: readonly FeatureEdit[], change: Record<string, unknown>, applyEdits: (edit: {
+    update: FeatureEdit;
+}) => Promise<ApplyEditsResult>): Promise<{
+    applied: FeatureEdit[];
+    rejected: {
+        feature: FeatureEdit;
+        reason: string;
+    }[];
+}>;
+export interface ElevationSample {
+    position: [number, number];
+    elevation: number;
+}
+export declare function sampleElevations(line: readonly [number, number][], terrain: {
+    elevationAt: (longitude: number, latitude: number) => number;
+} | undefined, spacing?: number): {
+    samples: ElevationSample[];
+    error?: string;
+};
+//# sourceMappingURL=widget-capabilities.d.ts.map