@honua/app-platform 0.1.0-beta.0 → 0.1.1-beta.0

package/web-components/maplibre-renderer.js

@@ -8,6 +8,8 @@ export class HonuaMapLibreRenderer {
     #lastViewportKey;
     #syncingViewport = false;
     #layerVisibility = new Map();
+    #layerOpacity = new Map();
+    #layerOrderKey;
     #selectionTarget;
     #featureStates = new Map();
     #state;
@@ -31,6 +33,8 @@ export class HonuaMapLibreRenderer {
                 return;
         }
         this.#applyLayerVisibility(state);
+        this.#applyLayerOpacity(state);
+        this.#applyLayerOrder(state);
         this.#applyViewport(state);
         this.#applyFeatureStates(state.featureStates);
         this.#applySelection(state);
@@ -44,6 +48,8 @@ export class HonuaMapLibreRenderer {
         this.#map = undefined;
         this.#loadedPackageKey = undefined;
         this.#layerVisibility.clear();
+        this.#layerOpacity.clear();
+        this.#layerOrderKey = undefined;
         this.#featureStates.clear();
         this.#selectionTarget = undefined;
         this.#options.container.replaceChildren();
@@ -88,6 +94,11 @@ export class HonuaMapLibreRenderer {
             }
             this.#runtime = runtime;
             this.#loadedPackageKey = mapPackageKey(mapPackage);
+            // Seed the order tracker with the order the map actually renders (the
+            // composed style), so a controller order that already diverged — e.g. a
+            // layer-list reorder issued while the package was still loading — is
+            // replayed by the next #applyLayerOrder pass instead of being absorbed.
+            this.#layerOrderKey = layerOrderKey(runtime.composedStyle.layers.map((layer) => layer.id));
             this.#bindViewport(map);
             this.#bindLayerInteractions(runtime);
             map.resize?.();
@@ -115,6 +126,8 @@ export class HonuaMapLibreRenderer {
         this.#map?.remove?.();
         this.#map = undefined;
         this.#layerVisibility.clear();
+        this.#layerOpacity.clear();
+        this.#layerOrderKey = undefined;
         this.#featureStates.clear();
         this.#selectionTarget = undefined;
         this.#options.container.replaceChildren();
@@ -248,6 +261,53 @@ export class HonuaMapLibreRenderer {
             }
         }
     }
+    #applyLayerOpacity(state) {
+        const map = this.#map;
+        if (!map?.setPaintProperty)
+            return;
+        for (const layer of state.layers) {
+            if (layer.opacity === undefined)
+                continue;
+            const previous = this.#layerOpacity.get(layer.id);
+            if (previous === layer.opacity)
+                continue;
+            this.#layerOpacity.set(layer.id, layer.opacity);
+            if (map.getLayer && !map.getLayer(layer.id))
+                continue;
+            for (const property of opacityPaintProperties(layer.type)) {
+                try {
+                    map.setPaintProperty(layer.id, property, layer.opacity);
+                }
+                catch (error) {
+                    this.#emitError(error);
+                }
+            }
+        }
+    }
+    #applyLayerOrder(state) {
+        const key = layerOrderKey(state.layers.map((layer) => layer.id));
+        // `#layerOrderKey` is seeded from the composed style order when the map
+        // package loads (see #load), so a matching key means the map already
+        // renders this order and overlays are never hoisted above host-managed
+        // base layers gratuitously. Any diverging key — including a reorder
+        // issued while the package was still loading — is replayed onto the map.
+        if (key === this.#layerOrderKey)
+            return;
+        this.#layerOrderKey = key;
+        const map = this.#map;
+        if (!map?.moveLayer)
+            return;
+        for (const layer of state.layers) {
+            if (map.getLayer && !map.getLayer(layer.id))
+                continue;
+            try {
+                map.moveLayer(layer.id);
+            }
+            catch (error) {
+                this.#emitError(error);
+            }
+        }
+    }
     #applyViewport(state) {
         if (this.#syncingViewport || !this.#runtime)
             return;
@@ -384,6 +444,33 @@ function featureStateKey(target) {
 function stableKey(value) {
     return JSON.stringify(value);
 }
+/** Order-tracking key over layer ids (NUL-delimited so ids with spaces stay distinct). */
+function layerOrderKey(ids) {
+    return ids.join("\u0000");
+}
+/** Paint properties that carry a layer's overall opacity, by layer type. */
+function opacityPaintProperties(type) {
+    switch (type) {
+        case "fill":
+            return ["fill-opacity"];
+        case "line":
+            return ["line-opacity"];
+        case "circle":
+            return ["circle-opacity", "circle-stroke-opacity"];
+        case "symbol":
+            return ["icon-opacity", "text-opacity"];
+        case "raster":
+            return ["raster-opacity"];
+        case "background":
+            return ["background-opacity"];
+        case "fill-extrusion":
+            return ["fill-extrusion-opacity"];
+        case "heatmap":
+            return ["heatmap-opacity"];
+        default:
+            return [];
+    }
+}
 function viewportKey(viewport) {
     return JSON.stringify({
         bbox: viewport.bbox,

package/web-components/measurement.d.ts

@@ -0,0 +1,69 @@
+/**
+ * `<honua-measurement>` — the survival-tier distance/area measurement widget
+ * (issue #493).
+ *
+ * Unlike `<honua-measure-control>` (which requires a host-supplied drawing
+ * provider), this element ships a complete, deliberately simple drawing
+ * interaction on top of the map's own pointer events:
+ *
+ * - **click** adds a vertex;
+ * - **double-click** finishes the sketch (the map's double-click zoom is
+ *   suspended while a mode is active when the map exposes the handle);
+ * - **Escape** (or the Cancel button) discards the in-progress sketch.
+ *
+ * Distance and area are computed with the geodesic ops from the public
+ * `@honua/geometry` surface (`length` / `area`), so the widget's numbers match
+ * `geometryEngine` parity math everywhere else in the SDK.
+ *
+ * ## Wiring
+ * - `element.map = map` (any MapLibre `Map`; duck-typed via
+ *   {@link HonuaMeasurementMap}), or
+ * - declaratively via `for="<honua-map id>"` — the element listens for the
+ *   `honua-map-ready` event dispatched by `<honua-map>`.
+ *
+ * When the map exposes style mutation methods (`addSource` / `addLayer`), the
+ * in-progress sketch renders as a line + fill overlay in a
+ * `honua-measurement` GeoJSON source; on plain stubs the overlay is skipped.
+ *
+ * ## Accessibility
+ * Mode buttons are a `role="group"` of toggle buttons with `aria-pressed`;
+ * the live result is announced through a `role="status"` region; Finish /
+ * Cancel buttons provide keyboard-operable equivalents of double-click /
+ * Escape. Theme via the `--honua-ui-*` CSS custom properties.
+ *
+ * @module
+ */
+import type { HonuaMeasureMode, HonuaMeasureResult, HonuaMeasurementMap } from "./types.js";
+declare const HTMLElementBase: typeof HTMLElement;
+type LngLat = readonly [number, number];
+export declare class HonuaMeasurementElement extends HTMLElementBase {
+    #private;
+    static get observedAttributes(): string[];
+    /** The MapLibre map this widget draws on. */
+    get map(): HonuaMeasurementMap | undefined;
+    set map(map: HonuaMeasurementMap | undefined);
+    /** Wires the widget to a MapLibre map. Equivalent to setting `.map`. */
+    connect(map: HonuaMeasurementMap): void;
+    /** The active measure mode. */
+    get mode(): HonuaMeasureMode;
+    /** The current (or last finished) measurement result. */
+    get result(): HonuaMeasureResult | undefined;
+    /** The in-progress vertex list (`[lng, lat]` positions). */
+    get vertices(): readonly LngLat[];
+    /** Activates a measure mode; `"off"` cancels any in-progress sketch. */
+    setMode(mode: HonuaMeasureMode): void;
+    /** Adds a vertex programmatically (same as a map click). */
+    addVertex(lngLat: LngLat): void;
+    /** Finishes the in-progress sketch (same as double-click). */
+    finish(): void;
+    /** Cancels the in-progress sketch (same as Escape); the mode stays active. */
+    cancel(): void;
+    attributeChangedCallback(name: string): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected render(): void;
+}
+/** Registers `<honua-measurement>`; skipped when the tag is already defined. */
+export declare function defineHonuaMeasurement(registry?: CustomElementRegistry): void;
+export {};
+//# sourceMappingURL=measurement.d.ts.map

package/web-components/measurement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"measurement.d.ts","sourceRoot":"","sources":["../../../src/web-components/measurement.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAGH,OAAO,KAAK,EAA4B,gBAAgB,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAQtH,QAAA,MAAM,eAAe,EAAE,OAAO,WAAkF,CAAC;AAMjH,KAAK,MAAM,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAExC,qBAAa,uBAAwB,SAAQ,eAAe;;IAC1D,WAAkB,kBAAkB,IAAI,MAAM,EAAE,CAE/C;IAaD,6CAA6C;IAC7C,IAAW,GAAG,IAAI,mBAAmB,GAAG,SAAS,CAEhD;IAED,IAAW,GAAG,CAAC,GAAG,EAAE,mBAAmB,GAAG,SAAS,EAMlD;IAED,wEAAwE;IACjE,OAAO,CAAC,GAAG,EAAE,mBAAmB,GAAG,IAAI;IAI9C,+BAA+B;IAC/B,IAAW,IAAI,IAAI,gBAAgB,CAElC;IAED,yDAAyD;IACzD,IAAW,MAAM,IAAI,kBAAkB,GAAG,SAAS,CAElD;IAED,4DAA4D;IAC5D,IAAW,QAAQ,IAAI,SAAS,MAAM,EAAE,CAEvC;IAED,wEAAwE;IACjE,OAAO,CAAC,IAAI,EAAE,gBAAgB,GAAG,IAAI;IAY5C,4DAA4D;IACrD,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAatC,8DAA8D;IACvD,MAAM,IAAI,IAAI;IASrB,8EAA8E;IACvE,MAAM,IAAI,IAAI;IAUd,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAQ5C,iBAAiB,IAAI,IAAI;IAQzB,oBAAoB,IAAI,IAAI;IAsMnC,SAAS,CAAC,MAAM,IAAI,IAAI;CAgFzB;AAED,gFAAgF;AAChF,wBAAgB,sBAAsB,CAAC,QAAQ,wBAA2B,GAAG,IAAI,CAKhF"}