@nika-js/onlymap 0.4.4 → 0.5.0

package/dist/cityjson.d.ts

@@ -0,0 +1,138 @@
+/**
+ * CityJSON / CityJSONSeq ingestion (spec: "CityJSON ingestion"; issue #25).
+ *
+ * A LAZY chunk — reached only through `CITYJSON_FORMAT`'s dynamic import in
+ * data-layer.ts, so neither this decoder nor proj4 weighs on the eager
+ * bundle (the src/raster.ts precedent). proj4 itself is imported lazily
+ * AGAIN inside `resolveCrs`, so a file already in lon/lat never pays for it.
+ *
+ * Two output shapes share one geometry computation (`computeCityObjectGeometry`):
+ *
+ *  - DEFAULT — one GeoJSON `Feature` per CityObject: a 2D footprint polygon
+ *    plus DERIVED height properties, rendered through GeoJsonLayer's
+ *    `extruded` + `get-elevation`. Lit, pickable, GPU-filterable,
+ *    terrain-aware — and, because extrusion is a flat-topped prism, it
+ *    cannot draw the actual shape of a pitched/hipped LoD2.2 roof no matter
+ *    how accurate the derived height is.
+ *  - `?om-surfaces=1` — one flat row PER FACE (wall, roof, ground), each
+ *    carrying its real 3D ring coordinates (real per-vertex height, not a
+ *    uniform extrusion) for `SolidPolygonLayer` with `extruded="false"` and
+ *    `full3d`. This draws the true reconstructed shape. The tradeoff: deck's
+ *    solid-polygon vertex shader computes lighting only inside its
+ *    `if (solidPolygon.extruded)` branch (verified against
+ *    solid-polygon-layer-vertex-main.glsl.js), so this path is unavoidably
+ *    unlit — flat per-face fill color, no shading from surface orientation.
+ *    `_full3d` is what makes near-vertical wall polygons triangulate at all:
+ *    without it earcut works in the flat xy plane, where a wall's projected
+ *    area is ~zero and the face silently vanishes.
+ *
+ * Semantics are not discarded in either mode: they drive which vertices
+ * count as roof (so the derived heights are real roof heights, not
+ * bounding-box heights) and survive as a `surface_type` per-face property in
+ * surfaces mode.
+ */
+/** [x, y, z] in the source CRS — decompressed, not yet reprojected. */
+type Vec3 = [number, number, number];
+/** A face is a list of rings; ring[0] is the outer boundary, the rest are holes. */
+type Face = number[][];
+interface CityJsonTransform {
+    scale?: number[];
+    translate?: number[];
+}
+interface CityJsonSemantics {
+    surfaces?: {
+        type?: string;
+    }[];
+    values?: unknown;
+}
+interface CityJsonGeometry {
+    type?: string;
+    lod?: string | number;
+    boundaries?: unknown;
+    semantics?: CityJsonSemantics;
+}
+interface CityObject {
+    type?: string;
+    attributes?: Record<string, unknown>;
+    geometry?: CityJsonGeometry[];
+    parents?: string[];
+    children?: string[];
+}
+export declare function decompressVertices(vertices: number[][] | undefined, transform: CityJsonTransform | undefined): Vec3[];
+/**
+ * Geometry → flat face list. Surface-less geometry types (points, lines) and
+ * anything unrecognized yield no faces, so the CityObject is skipped rather
+ * than emitted with a broken footprint.
+ */
+export declare function flattenToFaces(geometry: CityJsonGeometry): Face[];
+/** One semantic surface type per face (`"RoofSurface"`, …), aligned by index. */
+export declare function faceSemantics(geometry: CityJsonGeometry, faceCount: number): (string | undefined)[];
+/**
+ * Highest-LoD geometry that actually has surfaces. Higher LoD wins even though
+ * the output is an extrusion: an LoD2 solid carries real roof vertices and
+ * semantics, so its derived heights beat LoD1's single stated height.
+ * `?om-lod=` pins a specific one (see `parseCityJsonDocument`).
+ */
+export declare function chooseGeometry(geometries: CityJsonGeometry[] | undefined, lodPin?: number): CityJsonGeometry | undefined;
+/** `"https://www.opengis.net/def/crs/EPSG/0/7415"` / `"urn:ogc:def:crs:EPSG::7415"` / `"EPSG:7415"` → 7415. */
+export declare function parseEpsgCode(referenceSystem: string | undefined): number | undefined;
+/** Source [x, y] → WGS84 [lon, lat]. */
+export interface CrsAdapter {
+    toLngLat(x: number, y: number): [number, number];
+    /**
+     * True when source coordinates are already metres (a projected grid), so
+     * horizontal areas can be measured on them directly. Geographic sources are
+     * in degrees and need a local metric frame first — see `buildFeature`.
+     */
+    projected: boolean;
+}
+/**
+ * Build the reprojection adapter for a document. An unsupported EPSG code
+ * throws rather than silently misplacing a whole city — the failure surfaces
+ * through the Data Layer's own `Failed to fetch data="…"` path, the same as
+ * any other format error.
+ */
+export declare function resolveCrs(referenceSystem: string | undefined, url: string): Promise<CrsAdapter>;
+/** Derived property names. Documented as reserved — they win over same-named source attributes. */
+export interface DerivedProperties {
+    cityobject_id: string;
+    cityobject_type: string;
+    parent_id?: string;
+    lod?: string;
+    ground_height: number;
+    roof_height: number;
+    eaves_height: number;
+    ridge_height: number;
+    roof_area: number;
+    surface_count: number;
+}
+export declare function defaultFillColor(surfaceType: string | undefined, cityObjectType: string | undefined): string;
+/**
+ * CityObjects → features (default) or per-face surface rows (`mode:
+ * "surfaces"`, see `parseSurfacesFlag`). Geometry usually hangs off child
+ * objects (`BuildingPart`, `BridgePart`), so a parent's attributes are
+ * inherited by its children — the child's own values win, and `parent_id`
+ * keeps the hierarchy walkable for selection.
+ */
+export declare function decodeCityObjects(cityObjects: Record<string, CityObject> | undefined, vertices: Vec3[], crs: CrsAdapter, lodPin: number | undefined, mode?: "footprint" | "surfaces"): unknown[];
+/** `?om-lod=1.2` → 1.2. The DataFormat contract sees only the URL, so this is the option channel. */
+export declare function parseLodPin(url: string): number | undefined;
+/**
+ * `?om-surfaces=1` → per-face `SolidPolygonLayer` rows instead of the default
+ * footprint-extrusion `GeoJsonLayer` Features. Same option-channel idiom as
+ * `om-lod` — and the same URL-keyed cache benefit: a plain URL and its
+ * `?om-surfaces=1` counterpart parse and cache independently, so one manifest
+ * can point a `GeoJsonLayer` at one and a `SolidPolygonLayer` at the other.
+ */
+export declare function parseSurfacesFlag(url: string): boolean;
+/** A whole `.city.json` document. One JSON parse — a single JSON value has no incremental path. */
+export declare function parseCityJsonDocument(res: Response, url: string): Promise<unknown[]>;
+/**
+ * Streaming `.city.jsonl`. `push` hands the Data Layer a fresh array reference
+ * every batch so deck.gl's shallow `data` diff fires and the city fills in as
+ * it downloads; the returned array is the complete set.
+ */
+export declare function parseCityJsonSeq(res: Response, url: string, push: (features: unknown[]) => void): Promise<unknown[]>;
+/** Test hook — resets the once-per-page missing-CRS warning. */
+export declare function resetCityJsonWarningsForTests(): void;
+export {};

package/dist/data-layer.d.ts

@@ -70,6 +70,16 @@ export interface DataFormat {
     match(url: string, contentType?: string): boolean;
     /** Parse the claimed response. The parser module should be lazy-imported here (HU1 — the apache-arrow precedent). `url` is the requested URL (res.url is empty on constructed Responses — test fetches, service workers). */
     parse(res: Response, url: string): Promise<LayerData>;
+    /**
+     * Optional progressive variant for record-per-line formats (CityJSONSeq):
+     * `push` publishes a partial snapshot mid-download, taking the same
+     * cache-swap + notify path a stream flush takes, so the map fills in as
+     * bytes arrive instead of staying empty until EOF. Pass a FRESH array
+     * reference each time — deck.gl diffs `data` by identity. When present this
+     * is used instead of `parse`; the returned value is the complete dataset.
+     * `push` is a no-op during a `refresh` re-fetch — see getData for why.
+     */
+    parseIncremental?(res: Response, url: string, push: (partial: LayerData) => void): Promise<LayerData>;
 }
 /**
  * Row objects → ColumnarData (the memory-efficient shape: one array per

package/dist/elements/om-map.d.ts

@@ -55,6 +55,9 @@ export declare class OmMapElement extends HTMLElementBase {
     private errorPanel;
     private runtimeErrors;
     private readyFired;
+    private visibleSizeChecked;
+    /** Custom-state holder for the `om-collapsed` height-floor marker — see applyHeightFloor. */
+    private internals;
     private resolveReady;
     readonly ready: Promise<void>;
     private readonly viewSettle;
@@ -67,6 +70,8 @@ export declare class OmMapElement extends HTMLElementBase {
     private widgetLayer;
     private readonly slotContainers;
     private readonly mandatedChromeHosts;
+    /** Slots that host mandated chrome (badge/attribution) — set at host creation, so the collision-dim exemption is a slot-level flag, not a per-flush DOM scan. */
+    private readonly slotsWithMandatedChrome;
     private widgetResizeObserver;
     private widgetsFolded;
     private foldPassPending;
@@ -99,13 +104,22 @@ export declare class OmMapElement extends HTMLElementBase {
      * adapters mount/unmount the actual controls inside.
      */
     private ensureMandatedChromeHost;
+    /** True while an internal reparent (slotting/manual-flip) is moving a widget — its transient disconnect must NOT be read as an author removal. */
+    private inSlotReparent;
+    /** Wrap an internal reparent: suppress history AND flag it as a move so unregisterWidgetInternal keeps the fold/anchor bookkeeping. */
+    private reparent;
     slotWidgetInternal(el: HTMLElement, slot: WidgetSlot): void;
     /** Called by <om-widget> when its live `fold` attribute changes. */
     refreshWidgetFoldInternal(): void;
     private startWidgetFoldObserver;
+    private foldBreakpointRaw?;
+    private foldBreakpointCache;
+    /** Cached breakpoint resolution — re-probes only when the token string actually changes, not on every ResizeObserver tick. */
     private foldBreakpointPx;
     private measureWidgetFold;
     private updateWidgetFoldForWidth;
+    /** Lift the bottom-end row clear of the bottom drawer toggle while folded. Applied here AND in the fold pass so a lazily-created bottom-end container still gets it. */
+    private syncFoldBottomOffset;
     private scheduleFoldPass;
     private shouldFoldWidget;
     private ensureFoldDrawer;
@@ -172,6 +186,7 @@ export declare class OmMapElement extends HTMLElementBase {
      * modeled (headless has no rects; this no-ops there).
      */
     private dimSlotsAgainstOverlays;
+    /** widgets-toggle can sit in any author-chosen slot, so still scan for it (attribution/badge are covered by the slot flag). */
     private slotHasNeverHidesWidget;
     emit(event: string, payload?: Record<string, unknown>): void;
     /** Recenters (and optionally rezooms) the map — instant, not an animated fly. */
@@ -218,6 +233,20 @@ export declare class OmMapElement extends HTMLElementBase {
      */
     injectPickInternal(selection: Selection | null): void;
     injectDragPickInternal(selection: Selection): void;
+    /** Every click/hover map coordinate (spec: "Manual Drawing"): drives the
+     *  internal draw controller AND fires the public `om-map-point` event, so
+     *  consumer capture tools the built-in draw widget doesn't cover
+     *  (rectangle/circle AOIs) can subscribe. The two consumers are
+     *  DECOUPLED: the event dispatches first (dispatchEvent isolates a
+     *  throwing listener), then the draw controller runs — so neither a
+     *  throwing draw session nor a throwing listener can starve the other.
+     *  Fires at pointer rate on hover (no debounce — vertex capture needs
+     *  every point); heavy listeners should throttle their own work. */
+    private handleMapPoint;
+    /** Harness map-point injection (spec: "Consumer Testing Surface") — the
+     *  same path a real deck click/hover coordinate takes, so the om-map-point
+     *  event and custom capture tools are testable without a GPU. */
+    injectMapPointInternal(coordinate: [number, number] | null, kind?: "click" | "hover"): void;
     /** Harness setView (spec: "Consumer Testing Surface") — the one path that reaches pitch/bearing. */
     setViewInternal(partial: {
         longitude?: number;
@@ -258,6 +287,33 @@ export declare class OmMapElement extends HTMLElementBase {
     private dispatchRendererLoad;
     /** Fires `om-map-ready` / resolves `.ready` once the first reconcile ran, the renderer is up, and no declared data URL is still loading. */
     private checkReady;
+    /**
+     * Per-element half of the base-layout guardrail: mark the host `om-collapsed`
+     * so the layered `min-height` floor applies, but ONLY while it genuinely
+     * measures zero. Gating the floor this way is what lets an explicit author
+     * height win outright — a map with any height never carries the state, so the
+     * floor rule never matches it and a 300px map stays 300px.
+     *
+     * Clear-then-re-measure makes it idempotent and self-correcting: the connect-
+     * time call runs mid-parse, where a parent sized by later siblings still
+     * measures zero, and the post-ready call drops a floor that turned out to be
+     * unnecessary.
+     *
+     * A custom state rather than an attribute or inline style, deliberately: the
+     * host's own MutationObserver treats attribute writes as manifest edits (a
+     * reconcile), history.ts records them as undo steps, and either would
+     * serialize into a saved manifest. A custom state touches none of that.
+     */
+    private applyHeightFloor;
+    /**
+     * First-shot guardrail: warn (once) if the map has no visible size once it is
+     * ready. The base-layout default covers a bare `<om-map>`, but a constrained
+     * parent (a 0-height flex/grid cell, `height:100%` under an unsized ancestor)
+     * can still collapse it — a silent blank map otherwise.
+     * Skipped headless: jsdom/happy-dom report 0×0 by design, and `mountForTest`
+     * sets the `headless` attribute, so this never fires in the test harness.
+     */
+    private checkVisibleSize;
     private pickPayload;
     /**
      * Dispatches to every `<om-behavior on="eventName">` (live-queried, like
@@ -302,6 +358,20 @@ declare global {
             /** "user" if any change in the settled burst came from a canvas gesture; "programmatic" for pure API/action/story moves. */
             origin: "user" | "programmatic";
         }>;
+        /** Every click/hover's map coordinate (null when the pointer is off any
+         *  geometry deck can unproject) — the consumer hook for custom capture
+         *  tools beyond the built-in draw widget. */
+        "om-map-point": CustomEvent<{
+            coordinate: [number, number] | null;
+            kind: "click" | "hover";
+        }>;
+        /** A Tile3DLayer finished loading its root tileset — detail carries the
+         *  authored layer id and the live deck `Tileset3D` for tools (e.g. region
+         *  export) that need the real tileset, not the IR. */
+        "om-tileset-load": CustomEvent<{
+            layerId: string;
+            tileset: unknown;
+        }>;
     }
 }
 export {};

package/dist/{index-lXrP3rPo.js → index-BonJP_St.js}

@@ -1,4 +1,4 @@
-import { ac as _t, ad as Ct } from "./index-KgO0MBqA.js";
+import { ac as _t, ad as Ct } from "./index-DiYFebYs.js";
 function Yt(e, r, t = 2, i, o = "xy") {
   const s = r && r.length, l = s ? r[0] * t : e.length;
   let c = Ut(e, 0, l, t, !0, i && i[0], o);