@honua/app-platform 0.0.20-alpha.0

package/controls/legend.d.ts

@@ -0,0 +1,104 @@
+/**
+ * `<honua-legend>` — framework-free custom element rendering swatch+label
+ * rows from the same definitions the map uses (issue #274), so the map and
+ * its legend cannot drift apart.
+ *
+ * ## Input modes
+ * - **Explicit entries** — assign the `entries` property a flat
+ *   {@link HonuaLegendEntry} array (rendered as one untitled section) and/or
+ *   {@link HonuaLegendSection} groups with optional titles.
+ * - **Derive mode** (the headline) — set the `layer` attribute to a style
+ *   layer id; the element parses the layer's categorical color paint
+ *   expression into entries via {@link deriveLegendEntries}. See
+ *   `legend-derive.ts` for the supported expression shapes (literal color,
+ *   `match` on a `["get", <attr>]` input, simple-equality `case`, numeric
+ *   `step`); anything else fails gracefully — the element keeps rendering
+ *   its explicit sections and exposes the failure on `deriveError`.
+ *   Both modes compose: explicit sections render first, then the derived
+ *   section.
+ *
+ * ## Wiring
+ * - `element.map = map` (any MapLibre `Map`) or `element.connect(map)`;
+ * - declaratively via `for="<honua-map id>"` — same idiom as
+ *   `<honua-basemap-switcher>` (resolves `.map` from the referenced element
+ *   and listens for `honua-map-ready`).
+ *
+ * ## Reactivity
+ * - `refresh()` re-derives and re-renders on demand;
+ * - with the `auto-refresh` attribute, the element subscribes to the map's
+ *   `styledata` event while connected and refreshes automatically (style
+ *   edits, layers added later, visibility toggles).
+ *
+ * ## Attributes
+ * - `for` — id of the map-providing element.
+ * - `layer` — style layer id to derive entries from.
+ * - `layer-title` — optional title rendered above the derived section.
+ * - `heading` — optional heading rendered above the whole legend.
+ * - `follow-layer-visibility` — boolean; hide a section while its source
+ *   layer's `visibility` layout property is `"none"` (sections carry the
+ *   derived `layer` id or their own `layer` field).
+ * - `auto-refresh` — boolean; see Reactivity.
+ *
+ * ## CSS parts
+ * `root`, `heading`, `section`, `section-title`, `row`, `swatch`, `label`.
+ * Structural CSS only — theme via `::part()`.
+ *
+ * ## Accessibility
+ * Rows are real list items (`<ul>`/`<li>`); swatches are `aria-hidden`
+ * presentation, with the text labels carrying the meaning.
+ *
+ * Note: the `web-components` entry also registers a (controller-driven)
+ * `honua-legend` element. Both registrations are guarded with an if-missing
+ * check, so whichever entry is imported first owns the tag; import
+ * `@honua/sdk-js/controls` first to use this element.
+ */
+import { HTMLElementBase } from "./element-utils.js";
+import type { HonuaLegendEntry, HonuaLegendMap, HonuaLegendSection } from "./types.js";
+/**
+ * Custom element implementing the legend. Registered as `honua-legend` by
+ * `defineHonuaControls` (which runs automatically on import of the controls
+ * entry when a `customElements` registry exists).
+ */
+export declare class HonuaLegendElement extends HTMLElementBase {
+    #private;
+    static get observedAttributes(): string[];
+    /** The MapLibre map this legend reads from (derive mode and visibility coupling). */
+    get map(): HonuaLegendMap | undefined;
+    set map(map: HonuaLegendMap | undefined);
+    /** Wires the legend to a MapLibre map. Equivalent to setting `.map`. */
+    connect(map: HonuaLegendMap): void;
+    /**
+     * Explicit legend content. Accepts a flat {@link HonuaLegendEntry} array
+     * (one untitled section), {@link HonuaLegendSection} groups, or a mix;
+     * the getter returns the normalized sections. Invalid items are dropped.
+     */
+    get entries(): readonly HonuaLegendSection[];
+    set entries(value: readonly (HonuaLegendEntry | HonuaLegendSection)[]);
+    /** Style layer id used by derive mode. Reflects the `layer` attribute. */
+    get layer(): string | undefined;
+    set layer(value: string | undefined);
+    /** Hide sections whose source layer is hidden. Reflects `follow-layer-visibility`. */
+    get followLayerVisibility(): boolean;
+    set followLayerVisibility(value: boolean);
+    /** Refresh automatically on the map's `styledata` event. Reflects `auto-refresh`. */
+    get autoRefresh(): boolean;
+    set autoRefresh(value: boolean);
+    /**
+     * Why the last derive attempt failed (message of the underlying
+     * {@link HonuaLegendDeriveError}), or `undefined` while derive mode is
+     * succeeding or inactive.
+     */
+    get deriveError(): string | undefined;
+    /**
+     * The sections the legend renders: explicit sections followed by the
+     * derived section (when derive mode is active and succeeded).
+     */
+    get sections(): readonly HonuaLegendSection[];
+    /** Re-derives entries from the map (when in derive mode) and re-renders. */
+    refresh(): void;
+    attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected render(): void;
+}
+//# sourceMappingURL=legend.d.ts.map

package/controls/legend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"legend.d.ts","sourceRoot":"","sources":["../../../src/controls/legend.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAEH,OAAO,EACL,eAAe,EAKhB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,kBAAkB,EAA0B,MAAM,YAAY,CAAC;AAE/G;;;;GAIG;AACH,qBAAa,kBAAmB,SAAQ,eAAe;;IACrD,WAAkB,kBAAkB,IAAI,MAAM,EAAE,CAE/C;IAUD,qFAAqF;IACrF,IAAW,GAAG,IAAI,cAAc,GAAG,SAAS,CAE3C;IAED,IAAW,GAAG,CAAC,GAAG,EAAE,cAAc,GAAG,SAAS,EAM7C;IAED,wEAAwE;IACjE,OAAO,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI;IAIzC;;;;OAIG;IACH,IAAW,OAAO,IAAI,SAAS,kBAAkB,EAAE,CAElD;IAED,IAAW,OAAO,CAAC,KAAK,EAAE,SAAS,CAAC,gBAAgB,GAAG,kBAAkB,CAAC,EAAE,EAG3E;IAED,0EAA0E;IAC1E,IAAW,KAAK,IAAI,MAAM,GAAG,SAAS,CAErC;IAED,IAAW,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAIzC;IAED,sFAAsF;IACtF,IAAW,qBAAqB,IAAI,OAAO,CAE1C;IAED,IAAW,qBAAqB,CAAC,KAAK,EAAE,OAAO,EAE9C;IAED,qFAAqF;IACrF,IAAW,WAAW,IAAI,OAAO,CAEhC;IAED,IAAW,WAAW,CAAC,KAAK,EAAE,OAAO,EAEpC;IAED;;;;OAIG;IACH,IAAW,WAAW,IAAI,MAAM,GAAG,SAAS,CAE3C;IAED;;;OAGG;IACH,IAAW,QAAQ,IAAI,SAAS,kBAAkB,EAAE,CAQnD;IAED,4EAA4E;IACrE,OAAO,IAAI,IAAI;IAKf,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IAkB/F,iBAAiB,IAAI,IAAI;IASzB,oBAAoB,IAAI,IAAI;IAyEnC,SAAS,CAAC,MAAM,IAAI,IAAI;CAgDzB"}

package/controls/legend.js

@@ -0,0 +1,381 @@
+/**
+ * `<honua-legend>` — framework-free custom element rendering swatch+label
+ * rows from the same definitions the map uses (issue #274), so the map and
+ * its legend cannot drift apart.
+ *
+ * ## Input modes
+ * - **Explicit entries** — assign the `entries` property a flat
+ *   {@link HonuaLegendEntry} array (rendered as one untitled section) and/or
+ *   {@link HonuaLegendSection} groups with optional titles.
+ * - **Derive mode** (the headline) — set the `layer` attribute to a style
+ *   layer id; the element parses the layer's categorical color paint
+ *   expression into entries via {@link deriveLegendEntries}. See
+ *   `legend-derive.ts` for the supported expression shapes (literal color,
+ *   `match` on a `["get", <attr>]` input, simple-equality `case`, numeric
+ *   `step`); anything else fails gracefully — the element keeps rendering
+ *   its explicit sections and exposes the failure on `deriveError`.
+ *   Both modes compose: explicit sections render first, then the derived
+ *   section.
+ *
+ * ## Wiring
+ * - `element.map = map` (any MapLibre `Map`) or `element.connect(map)`;
+ * - declaratively via `for="<honua-map id>"` — same idiom as
+ *   `<honua-basemap-switcher>` (resolves `.map` from the referenced element
+ *   and listens for `honua-map-ready`).
+ *
+ * ## Reactivity
+ * - `refresh()` re-derives and re-renders on demand;
+ * - with the `auto-refresh` attribute, the element subscribes to the map's
+ *   `styledata` event while connected and refreshes automatically (style
+ *   edits, layers added later, visibility toggles).
+ *
+ * ## Attributes
+ * - `for` — id of the map-providing element.
+ * - `layer` — style layer id to derive entries from.
+ * - `layer-title` — optional title rendered above the derived section.
+ * - `heading` — optional heading rendered above the whole legend.
+ * - `follow-layer-visibility` — boolean; hide a section while its source
+ *   layer's `visibility` layout property is `"none"` (sections carry the
+ *   derived `layer` id or their own `layer` field).
+ * - `auto-refresh` — boolean; see Reactivity.
+ *
+ * ## CSS parts
+ * `root`, `heading`, `section`, `section-title`, `row`, `swatch`, `label`.
+ * Structural CSS only — theme via `::part()`.
+ *
+ * ## Accessibility
+ * Rows are real list items (`<ul>`/`<li>`); swatches are `aria-hidden`
+ * presentation, with the text labels carrying the meaning.
+ *
+ * Note: the `web-components` entry also registers a (controller-driven)
+ * `honua-legend` element. Both registrations are guarded with an if-missing
+ * check, so whichever entry is imported first owns the tag; import
+ * `@honua/sdk-js/controls` first to use this element.
+ */
+import { HTMLElementBase, escapeAttribute, escapeHtml, listenForHonuaMapReady, resolveHonuaMapFromContext, } from "./element-utils.js";
+import { HonuaLegendDeriveError, deriveLegendEntries } from "./legend-derive.js";
+/**
+ * Custom element implementing the legend. Registered as `honua-legend` by
+ * `defineHonuaControls` (which runs automatically on import of the controls
+ * entry when a `customElements` registry exists).
+ */
+export class HonuaLegendElement extends HTMLElementBase {
+    static get observedAttributes() {
+        return ["for", "layer", "layer-title", "heading", "follow-layer-visibility", "auto-refresh"];
+    }
+    #map;
+    #explicitSections = [];
+    #derivedEntries;
+    #deriveError;
+    #connected = false;
+    #disposeMapReadyListener;
+    #styledataListener;
+    /** The MapLibre map this legend reads from (derive mode and visibility coupling). */
+    get map() {
+        return this.#map;
+    }
+    set map(map) {
+        if (this.#map === map)
+            return;
+        this.#unsubscribeStyledata();
+        this.#map = map;
+        this.refresh();
+        this.#subscribeStyledata();
+    }
+    /** Wires the legend to a MapLibre map. Equivalent to setting `.map`. */
+    connect(map) {
+        this.map = map;
+    }
+    /**
+     * Explicit legend content. Accepts a flat {@link HonuaLegendEntry} array
+     * (one untitled section), {@link HonuaLegendSection} groups, or a mix;
+     * the getter returns the normalized sections. Invalid items are dropped.
+     */
+    get entries() {
+        return this.#explicitSections;
+    }
+    set entries(value) {
+        this.#explicitSections = normalizeSections(value);
+        this.render();
+    }
+    /** Style layer id used by derive mode. Reflects the `layer` attribute. */
+    get layer() {
+        return this.#attr("layer") ?? undefined;
+    }
+    set layer(value) {
+        if (typeof this.setAttribute !== "function")
+            return;
+        if (value === undefined)
+            this.removeAttribute?.("layer");
+        else
+            this.setAttribute("layer", value);
+    }
+    /** Hide sections whose source layer is hidden. Reflects `follow-layer-visibility`. */
+    get followLayerVisibility() {
+        return this.#hasAttr("follow-layer-visibility");
+    }
+    set followLayerVisibility(value) {
+        this.#setBooleanAttr("follow-layer-visibility", value);
+    }
+    /** Refresh automatically on the map's `styledata` event. Reflects `auto-refresh`. */
+    get autoRefresh() {
+        return this.#hasAttr("auto-refresh");
+    }
+    set autoRefresh(value) {
+        this.#setBooleanAttr("auto-refresh", value);
+    }
+    /**
+     * Why the last derive attempt failed (message of the underlying
+     * {@link HonuaLegendDeriveError}), or `undefined` while derive mode is
+     * succeeding or inactive.
+     */
+    get deriveError() {
+        return this.#deriveError;
+    }
+    /**
+     * The sections the legend renders: explicit sections followed by the
+     * derived section (when derive mode is active and succeeded).
+     */
+    get sections() {
+        const layerId = this.layer;
+        if (!this.#derivedEntries || !layerId)
+            return this.#explicitSections;
+        const title = this.#attr("layer-title");
+        return [
+            ...this.#explicitSections,
+            { ...(title !== null ? { title } : {}), layer: layerId, entries: this.#derivedEntries },
+        ];
+    }
+    /** Re-derives entries from the map (when in derive mode) and re-renders. */
+    refresh() {
+        this.#derive();
+        this.render();
+    }
+    attributeChangedCallback(name, _oldValue, newValue) {
+        if (name === "for") {
+            this.#resolveMapFromContext();
+            return;
+        }
+        if (name === "layer" || name === "layer-title") {
+            this.refresh();
+            return;
+        }
+        if (name === "auto-refresh") {
+            if (newValue === null)
+                this.#unsubscribeStyledata();
+            else
+                this.#subscribeStyledata();
+            return;
+        }
+        // "heading" / "follow-layer-visibility" only change the rendering.
+        this.render();
+    }
+    connectedCallback() {
+        this.#connected = true;
+        this.#ensureShadowRoot();
+        this.#listenForMapReady();
+        this.#resolveMapFromContext();
+        this.#subscribeStyledata();
+        this.refresh();
+    }
+    disconnectedCallback() {
+        this.#connected = false;
+        this.#disposeMapReadyListener?.();
+        this.#disposeMapReadyListener = undefined;
+        this.#unsubscribeStyledata();
+    }
+    // ── derive mode ────────────────────────────────────────────
+    #derive() {
+        this.#derivedEntries = undefined;
+        const layerId = this.layer;
+        const map = this.#map;
+        if (!layerId || !map) {
+            this.#deriveError = undefined;
+            return;
+        }
+        try {
+            this.#derivedEntries = deriveLegendEntries(map, layerId);
+            this.#deriveError = undefined;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            // A missing layer is usually transient (style still loading), so it is
+            // not warned about; real shape mismatches are warned once per message.
+            const transient = error instanceof HonuaLegendDeriveError && error.code === "layer-not-found";
+            if (!transient && message !== this.#deriveError && typeof console !== "undefined") {
+                console.warn(`<honua-legend> could not derive entries: ${message}`);
+            }
+            this.#deriveError = message;
+        }
+    }
+    // ── 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);
+    }
+    // ── rendering ──────────────────────────────────────────────
+    #ensureShadowRoot() {
+        if (!this.shadowRoot && typeof this.attachShadow === "function") {
+            this.attachShadow({ mode: "open" });
+        }
+    }
+    render() {
+        const root = this.shadowRoot;
+        if (!root)
+            return;
+        const heading = this.#attr("heading");
+        root.innerHTML = `
+      <style>${structuralStyles()}</style>
+      <div part="root" class="root">
+        ${heading ? `<p part="heading" class="heading">${escapeHtml(heading)}</p>` : ""}
+        ${this.sections.map((section) => this.#renderSection(section)).join("")}
+      </div>
+    `;
+    }
+    #renderSection(section) {
+        const hidden = this.#sectionHidden(section);
+        return `
+      <section part="section" class="section"${hidden ? " hidden" : ""}${section.layer ? ` data-layer="${escapeAttribute(section.layer)}"` : ""}>
+        ${section.title ? `<p part="section-title" class="section-title">${escapeHtml(section.title)}</p>` : ""}
+        <ul class="rows">
+          ${section.entries.map((entry) => renderRow(entry)).join("")}
+        </ul>
+      </section>
+    `;
+    }
+    #sectionHidden(section) {
+        if (!this.followLayerVisibility || !section.layer)
+            return false;
+        return this.#map?.getLayoutProperty?.(section.layer, "visibility") === "none";
+    }
+    // ── 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;
+    }
+    #setBooleanAttr(name, value) {
+        if (typeof this.setAttribute !== "function")
+            return;
+        if (value)
+            this.setAttribute(name, "");
+        else
+            this.removeAttribute?.(name);
+    }
+}
+function normalizeSections(value) {
+    const sections = [];
+    let loose = [];
+    const flushLoose = () => {
+        if (loose.length > 0)
+            sections.push({ entries: loose });
+        loose = [];
+    };
+    for (const item of value ?? []) {
+        if (isSection(item)) {
+            flushLoose();
+            const entries = item.entries.filter(isEntry).map(normalizeEntry);
+            sections.push({
+                ...(typeof item.title === "string" ? { title: item.title } : {}),
+                ...(typeof item.layer === "string" ? { layer: item.layer } : {}),
+                entries,
+            });
+        }
+        else if (isEntry(item)) {
+            loose.push(normalizeEntry(item));
+        }
+    }
+    flushLoose();
+    return sections;
+}
+function isSection(item) {
+    return typeof item === "object" && item !== null && Array.isArray(item.entries);
+}
+function isEntry(item) {
+    if (typeof item !== "object" || item === null)
+        return false;
+    const entry = item;
+    if (typeof entry.label !== "string")
+        return false;
+    if (typeof entry.color === "string")
+        return true;
+    return (typeof entry.color === "object" &&
+        entry.color !== null &&
+        (entry.color.fill === undefined || typeof entry.color.fill === "string") &&
+        (entry.color.outline === undefined || typeof entry.color.outline === "string"));
+}
+function normalizeEntry(entry) {
+    const shape = isSwatchShape(entry.shape) ? entry.shape : "fill";
+    return { label: entry.label, color: entry.color, shape };
+}
+function isSwatchShape(value) {
+    return value === "fill" || value === "line" || value === "circle";
+}
+function renderRow(entry) {
+    const fill = typeof entry.color === "string" ? entry.color : entry.color.fill;
+    const outline = typeof entry.color === "object" && entry.color !== null ? entry.color.outline : undefined;
+    const shape = entry.shape ?? "fill";
+    const swatchStyle = [
+        ...(fill !== undefined ? [`--legend-fill:${fill}`] : []),
+        ...(outline !== undefined ? [`--legend-outline:${outline}`] : []),
+    ].join(";");
+    return `
+    <li part="row" class="row">
+      <span part="swatch" class="swatch swatch-${shape}" aria-hidden="true"${swatchStyle ? ` style="${escapeAttribute(swatchStyle)}"` : ""}></span>
+      <span part="label" class="label">${escapeHtml(entry.label)}</span>
+    </li>
+  `;
+}
+/** Structural-only styles; theme via `::part(root)`, `::part(row)`, `::part(swatch)`, ... */
+function structuralStyles() {
+    return `
+    :host { display: block; }
+    .heading, .section-title { margin: 0; }
+    .section { margin: 0; }
+    .rows { list-style: none; margin: 0; padding: 0; }
+    .row { display: flex; align-items: center; gap: 0.5em; }
+    .swatch {
+      flex: none;
+      inline-size: 1em;
+      block-size: 1em;
+      box-sizing: border-box;
+      background: var(--legend-fill, transparent);
+      border: 1px solid var(--legend-outline, transparent);
+    }
+    .swatch-line { block-size: 3px; border: none; }
+    .swatch-circle { border-radius: 50%; }
+  `;
+}

package/controls/swipe-control.d.ts

@@ -0,0 +1,80 @@
+/**
+ * `<honua-swipe-control>` — framework-free custom element implementing the
+ * dual-map "swipe"/compare trick (issue #279, candidate third control for the
+ * native kit, #274).
+ *
+ * Two MapLibre maps are stacked (the host positions them; the control does
+ * not own layout) and the control clips the **top** map against the **bottom**
+ * map along a draggable divider via CSS `clip-path`. Dragging the divider (or
+ * using the keyboard) reveals more or less of each map and emits a `change`
+ * event with the divider position.
+ *
+ * Like the other controls, this element imports nothing from `maplibre-gl` or
+ * the SDK core — it drives any MapLibre `Map` through the duck-typed
+ * {@link HonuaSwipeMap} interface (it only needs `getContainer()`), so the
+ * `@honua/sdk-js/controls` entry stays bundle-independent. Node imports are
+ * safe; the element no-ops without a DOM.
+ *
+ * ## Wiring
+ * - `element.topMap = map` / `element.bottomMap = map`, or
+ *   `element.connect(topMap, bottomMap)`. The top map is the one that gets
+ *   clipped; the bottom map shows through the revealed region.
+ *
+ * ## Attributes
+ * - `position` — divider position as a percentage 0–100 (default 50).
+ * - `orientation` — `"vertical"` (default) or `"horizontal"`.
+ * - `label` — accessible name of the divider (default "Compare maps").
+ *
+ * ## Events
+ * - `change` — `CustomEvent<HonuaSwipeChangeDetail>` (bubbles, composed)
+ *   whenever the divider position changes: drag, keyboard, or programmatic
+ *   `position` assignment.
+ *
+ * ## CSS parts
+ * - `divider` — the full-length divider line.
+ * - `handle` — the draggable grip on the divider.
+ *
+ * ## Accessibility
+ * The divider is an ARIA slider (`role="slider"`, `aria-valuenow/min/max`,
+ * `aria-orientation`) with arrow-key control (ArrowLeft/ArrowRight or
+ * ArrowUp/ArrowDown step by 1, Home/End jump to 0/100, with Shift = 10).
+ *
+ * @module
+ */
+import { HTMLElementBase } from "./element-utils.js";
+import type { HonuaSwipeMap, HonuaSwipeOrientation } from "./types.js";
+/**
+ * Custom element implementing the dual-map swipe/compare divider. Registered
+ * as `honua-swipe-control` by {@link defineHonuaSwipeControl} (which runs
+ * automatically on import when a `customElements` registry exists).
+ */
+export declare class HonuaSwipeControlElement extends HTMLElementBase {
+    #private;
+    static get observedAttributes(): string[];
+    /** The clipped (overlay) map. Reapplies the clip when assigned. */
+    get topMap(): HonuaSwipeMap | undefined;
+    set topMap(map: HonuaSwipeMap | undefined);
+    /** The underlying map revealed by the clip. */
+    get bottomMap(): HonuaSwipeMap | undefined;
+    set bottomMap(map: HonuaSwipeMap | undefined);
+    /** Wires both maps at once. The first map is clipped against the second. */
+    connect(topMap: HonuaSwipeMap, bottomMap?: HonuaSwipeMap): void;
+    /** Divider position as a percentage 0–100. Reflects the `position` attribute. */
+    get position(): number;
+    set position(value: number);
+    /** Divider orientation. Reflects the `orientation` attribute. */
+    get orientation(): HonuaSwipeOrientation;
+    set orientation(value: HonuaSwipeOrientation);
+    attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected render(): void;
+}
+/**
+ * Registers the swipe control custom element (`honua-swipe-control`). Invoked
+ * automatically on import when a global `customElements` registry is present;
+ * call explicitly when using a scoped registry. Skips the registration when
+ * the tag is already defined.
+ */
+export declare function defineHonuaSwipeControl(registry?: CustomElementRegistry): void;
+//# sourceMappingURL=swipe-control.d.ts.map

package/controls/swipe-control.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swipe-control.d.ts","sourceRoot":"","sources":["../../../src/controls/swipe-control.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,EAAE,eAAe,EAA8B,MAAM,oBAAoB,CAAC;AACjF,OAAO,KAAK,EAA0B,aAAa,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAM/F;;;;GAIG;AACH,qBAAa,wBAAyB,SAAQ,eAAe;;IAC3D,WAAkB,kBAAkB,IAAI,MAAM,EAAE,CAE/C;IASD,mEAAmE;IACnE,IAAW,MAAM,IAAI,aAAa,GAAG,SAAS,CAE7C;IAED,IAAW,MAAM,CAAC,GAAG,EAAE,aAAa,GAAG,SAAS,EAI/C;IAED,+CAA+C;IAC/C,IAAW,SAAS,IAAI,aAAa,GAAG,SAAS,CAEhD;IAED,IAAW,SAAS,CAAC,GAAG,EAAE,aAAa,GAAG,SAAS,EAElD;IAED,4EAA4E;IACrE,OAAO,CAAC,MAAM,EAAE,aAAa,EAAE,SAAS,CAAC,EAAE,aAAa,GAAG,IAAI;IAKtE,iFAAiF;IACjF,IAAW,QAAQ,IAAI,MAAM,CAE5B;IAED,IAAW,QAAQ,CAAC,KAAK,EAAE,MAAM,EAEhC;IAED,iEAAiE;IACjE,IAAW,WAAW,IAAI,qBAAqB,CAE9C;IAED,IAAW,WAAW,CAAC,KAAK,EAAE,qBAAqB,EAGlD;IAEM,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IAgB/F,iBAAiB,IAAI,IAAI;IAMzB,oBAAoB,IAAI,IAAI;IA4CnC,SAAS,CAAC,MAAM,IAAI,IAAI;CAoJzB;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,wBAA2B,GAAG,IAAI,CAKjF"}