@nika-js/onlymap 0.5.12 → 0.6.1

package/dist/crs.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Bundled coordinate reference systems, shared by every decoder that has to
+ * turn projected coordinates into lon/lat.
+ *
+ * Extracted from cityjson.ts so the IFC path can reuse it. An IFC file's
+ * `IfcMapConversion` states its position in a projected CRS named by
+ * `IfcProjectedCRS`, exactly as CityJSON states one in
+ * `metadata.referenceSystem`, so both need the same table and the same lazy
+ * proj4 import. Duplicating it would have meant a Dutch model georeferencing
+ * correctly as CityJSON and 108 m out as IFC.
+ *
+ * proj4 is imported LAZILY at the point of use, never at module scope: most
+ * files need no projection at all, and the ones that do are already paying for
+ * a parse.
+ */
+export interface CrsEntry {
+    def: string;
+    /** Source stores [northing, easting] / [lat, lon] — swap before handing to proj4. */
+    swapXY?: boolean;
+    /** Already angular: no reprojection, but horizontal metrics need a local metric frame. */
+    geographic?: boolean;
+}
+/** Compound (horizontal + vertical) codes → the horizontal component that actually projects. */
+export declare const COMPOUND_TO_HORIZONTAL: Record<number, number>;
+export declare const CRS_DEFS: Record<number, CrsEntry>;
+/** The EPSG codes this build can convert without help. */
+export declare function bundledCrsCodes(): number[];
+/**
+ * Projected (or geographic) coordinates in EPSG:`code` -> `[lon, lat]`.
+ *
+ * Returns null when the code is not bundled, which callers must treat as "I
+ * cannot place this" rather than silently substituting something else — a
+ * wrong position looks exactly like a right one.
+ *
+ * `x`/`y` are given easting-first; entries flagged `swapXY` (Japan's plane
+ * systems, RD's formal axis order) are swapped here so callers never have to
+ * know which convention a CRS uses.
+ */
+export declare function projectedToLonLat(code: number, x: number, y: number): Promise<[number, number] | null>;
+/**
+ * Bearing of the projection's GRID north at a point, in degrees clockwise from
+ * true north — the grid convergence.
+ *
+ * Measured rather than derived: unproject the point and a second one a short
+ * step further north IN GRID SPACE, then take the true bearing between them.
+ * That works for any projection in the table without per-CRS formulae, and it
+ * matters because a model aligned to a national grid is NOT aligned to true
+ * north. Dutch RD at Rotterdam is off by -0.735 degrees.
+ */
+export declare function gridConvergence(code: number, x: number, y: number, step?: number): Promise<number | null>;

package/dist/ctx.d.ts

@@ -35,6 +35,12 @@ export interface RuntimeContext {
         project(lngLat: [number, number]): [number, number];
     };
     selection: Selection | null;
+    /**
+     * The decoded EXT_structural_metadata property table for a `pick-features`
+     * layer, indexed BY feature ID, or null before its first tile has loaded.
+     * Watch the `features` token to re-render when it arrives.
+     */
+    features(layerId: string): Record<string, unknown>[] | null;
     /** Manifest undo/redo state (spec: "Undo / Redo — Manifest History") — drive it via emit("undo"/"redo"). Always false on the programmatic/React path (the app owns state there). */
     history: {
         canUndo: boolean;
@@ -49,6 +55,7 @@ export interface RuntimeContext {
 }
 export interface BuildCtxDeps {
     layerIRs: ReadonlyMap<string, LayerIR>;
+    featureTables?: ReadonlyMap<string, Record<string, unknown>[]>;
     core: RuntimeCore;
     mapEl: Element;
     selection: Selection | null;
@@ -62,4 +69,4 @@ export declare function viewportBounds(viewport: ReturnType<RuntimeCore["getView
 /** `ctx.layers` / the `layers` external store — one builder for both (spec: "External-Store Contract"). */
 export declare function buildLayerMetas(layerIRs: ReadonlyMap<string, LayerIR>): LayerMetaSnapshot[];
 /** Built fresh on every widget-render invocation — never mutated, never reused. */
-export declare function buildCtx({ layerIRs, core, mapEl, selection, history }: BuildCtxDeps): RuntimeContext;
+export declare function buildCtx({ layerIRs, core, mapEl, selection, history, featureTables }: BuildCtxDeps): RuntimeContext;

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

@@ -23,11 +23,12 @@ import { type LightingIR } from "../scene-lighting";
 import { type TerrainIR } from "../terrain";
 import { type WidgetSlot } from "../widget-layout";
 import { type SnapshotOptions } from "../snapshot";
+import { type ValidationEntry } from "../validation";
 import type { LayerIR } from "../ir";
 import type { Selection } from "../selection";
 import type { MapViewport } from "../basemap";
 interface OverlayHost {
-    updatePosition(viewport: MapViewport | undefined, selection: Selection | null): void;
+    updatePosition(viewport: MapViewport | undefined, selection: Selection | null, pickType?: "hover" | "click"): void;
     /**
      * Screen rect for collision-dim (spec: "Overlap avoidance") — non-null
      * only when the overlay is VISIBLE and participates in dimming. Returns
@@ -47,13 +48,26 @@ export declare class OmMapElement extends HTMLElementBase {
     private contextmenuHandler?;
     private mount;
     private reconcilePending;
+    /** Decoded property tables per pick-features layer — see RuntimeCoreCallbacks.onFeatureTable. */
+    private featureTables;
     private layerIRs;
     private selection;
+    /**
+     * The pointer event behind the most recent pick — kept SEPARATELY from
+     * `selection` because empty picks store `selection = null`, losing their
+     * type, yet `selection-type`-scoped overlays must tell a click on empty
+     * space (dismisses a click popup) from a hover over empty space (inert).
+     */
+    private lastPickType;
     private widgets;
     private overlays;
     private overlayFlushPending;
     private errorPanel;
     private runtimeErrors;
+    /** Dedup guard for the approximate-BIM-georeferencing warning — same shape as applyLicenseGates' own `warned` set, keyed per layer id. */
+    private warnedApproximatePlacement;
+    /** Dedup guard for the no-terrain-for-elevation error — same shape as `warnedApproximatePlacement`. */
+    private erroredNoTerrainForElevation;
     private readyFired;
     private visibleSizeChecked;
     /** Custom-state holder for the `om-collapsed` height-floor marker — see applyHeightFloor. */
@@ -231,7 +245,7 @@ export declare class OmMapElement extends HTMLElementBase {
      * by mountForTest's pick()/clearSelection(), not part of the public
      * authoring surface.
      */
-    injectPickInternal(selection: Selection | null): void;
+    injectPickInternal(selection: Selection | null, pickType?: "hover" | "click"): 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
@@ -341,6 +355,16 @@ export declare class OmMapElement extends HTMLElementBase {
      * still runs validation and fires the event, just skips the on-page panel
      * (spec: "for teams building their own error UI").
      */
+    /**
+     * Reports a runtime-discovered validation entry — deck.gl crashes and
+     * license-limit violations already flow through this (via `onRuntimeError`
+     * below); this is also the entry point for facts a WIDGET discovers
+     * directly (no round trip through RuntimeCore) since it already holds an
+     * `<om-map>` reference — see `ifc-loader`'s approximate-georeferencing
+     * warning. Same access-pattern precedent as `registerWidgetInternal`
+     * above: real and callable, not part of the documented public API.
+     */
+    reportRuntimeErrorInternal(entry: ValidationEntry): void;
     private publishValidation;
 }
 declare global {

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

@@ -86,5 +86,5 @@ export declare class OmOverlayElement extends HTMLElementBase {
      * must not flicker widgets). Only stable author popups drive dimming.
      */
     getVisibleRect(): DOMRect | null;
-    updatePosition(viewport: MapViewport | undefined, selection: Selection | null): void;
+    updatePosition(viewport: MapViewport | undefined, selection: Selection | null, pickType?: "hover" | "click"): void;
 }

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

@@ -22,6 +22,10 @@ export declare class OmWidgetElement extends HTMLElementBase implements WidgetHo
     private renderFn?;
     private watchTokens;
     private hostStyle;
+    /** The registered implementation behind `type="…"` — kept so real removal can call its optional destroy() hook. */
+    private impl;
+    /** One pending real-removal check at a time — a remove→insert→remove within a single task must not run destroy twice. */
+    private destroyCheckPending;
     /** Live placement attributes (spec: "Widget Layout Manager") — position/order edits (incl. undo replays) re-slot without a remount. */
     static readonly observedAttributes: string[];
     connectedCallback(): void;

package/dist/feature-colors.d.ts

@@ -0,0 +1,41 @@
+/** Colour-blind-safe categorical default, cycled when a field has more values than entries. */
+export declare const FEATURE_PALETTE: string[];
+export declare const FEATURE_RAMP: string[];
+export declare function resolveFeatureColor(entry: unknown): [number, number, number];
+/**
+ * The GLOBAL half of feature colouring — everything derived from the WHOLE
+ * accumulated table, none of it indexed by feature ID. Serializable on
+ * purpose (`order` is entries, not a Map): its identity is the memo key that
+ * keeps per-tile style tables (and their GPU textures) stable across
+ * reconciles and animation frames.
+ */
+export interface FeatureColorMapping {
+    kind: "categorical" | "graduated";
+    field: string;
+    /** graduated: the max across every loaded tile (colours stay comparable as tiles stream in). */
+    max?: number;
+    /** categorical: global value → first-seen order (assigns each value a stable palette slot). */
+    order?: [string, number][];
+    /** Resolved palette/ramp — author `feature-palette` or the built-in defaults. */
+    colors: unknown[];
+    strength: number;
+}
+/**
+ * Builds the mapping from the layer's ACCUMULATED rows (all tiles).
+ * Returns null when neither colouring attribute is asked for — the model then
+ * renders in its own IFC surface colours. Authored `feature-styles` always
+ * wins upstream: the declarative attributes are sugar over the same table,
+ * never an override of it.
+ */
+export declare function buildFeatureColorMapping(rows: Record<string, unknown>[], categorical: string | undefined, graduated: string | undefined, palette: unknown[] | undefined, strength: number): FeatureColorMapping | null;
+/**
+ * Applies the mapping to ONE tile's own rows — the per-tile style table, index
+ * = that tile's local feature ID. A category unseen in the global order (a
+ * race while tiles stream; the next accumulate pass rebuilds the mapping)
+ * falls back to slot 0 rather than being unstyled, matching the pre-split
+ * behavior for unknown values.
+ */
+export declare function applyFeatureColorMapping(rows: Record<string, unknown>[], mapping: FeatureColorMapping): {
+    color: [number, number, number];
+    strength: number;
+}[];

package/dist/{geoparquet-Dn1BypCS.js → geoparquet-Dix4lTNy.js}

@@ -1,4 +1,4 @@
-import { r as p, n as d } from "./index-aBiHCzy-.js";
+import { r as p, n as d } from "./index-1UgNlfGR.js";
 function g(t) {
   if (t == null) return !0;
   const e = t, n = e.id?.code;

package/dist/html-data.d.ts

@@ -17,7 +17,7 @@ interface TagData {
 /** Hand-authored action list — validated against hasAction() in html-data.test.ts. */
 export declare const BUILTIN_ACTIONS: readonly ["toggle-layer", "zoom-in", "zoom-out", "filter-layer", "highlight-feature", "fade", "pulse", "populate", "trace", "story-play", "story-pause", "story-seek", "fly-to", "zoom-to-feature", "show-overlay", "hide-overlay", "show-tooltip", "hide-tooltip", "draw-mode", "draw-commit", "draw-cancel", "draw-delete", "draw-clear", "draw-config", "draw-save", "measure-mode", "measure-clear", "measure-units", "set-basemap", "set-lighting", "set-terrain", "set-widgets-visible", "undo", "redo"];
 /** Hand-authored widget types — validated against the widget registry in html-data.test.ts. */
-export declare const BUILTIN_WIDGETS: readonly ["legend", "layer-switcher", "zoom-controls", "scale-bar", "attribution", "filter", "vega-lite", "player", "draw", "measure", "basemap-switcher", "lighting", "undo-redo", "widgets-toggle"];
+export declare const BUILTIN_WIDGETS: readonly ["legend", "layer-switcher", "zoom-controls", "scale-bar", "attribution", "filter", "vega-lite", "player", "draw", "measure", "basemap-switcher", "lighting", "undo-redo", "widgets-toggle", "ifc-browser", "ifc-legend", "feature-inspector", "ifc-inspector", "ifc-loader", "ifc-clash"];
 export declare function buildHtmlCustomData(): {
     version: number;
     tags: TagData[];