@nika-js/onlymap 0.6.13 → 0.6.15

package/CHANGELOG.md

@@ -8,6 +8,19 @@ Note: npm collapsed a few closely-spaced releases — the GPX/FlatGeobuf (0.5.4)
 and GeoParquet (0.5.5) work shipped to npm together as **0.5.6**, so npm's
 version list jumps 0.5.3 → 0.5.6. Each logical version is listed here regardless.
 
+## 0.6.15 — 2026-08-21
+
+### Changed
+- **Smoother interactive dragging on complex maps.** Dragging the measure or clip-box gizmos (and any other live animation) now rebuilds the scene once per frame instead of up to ~10 times — the same visual result with a fraction of the work, which shows up as steadier frame rates and lower battery drain on layer-heavy maps, especially in mobile WebViews.
+
+## 0.6.14 — 2026-08-21
+
+### Fixed
+- **Dashed lines render again.** `dash="[4, 2]"` had been drawing solid lines since 0.6.2 — the terrain patch merge was unintentionally stripping every layer's extensions on flat maps (issue #36).
+- **Filters visibly apply again on maps without terrain** — same underlying cause as the dash fix. Filter widgets and statistics were always correct; the map itself just wasn't hiding filtered-out features.
+- **Maps built in code now match maps built in HTML.** Built-in defaults apply (e.g. BIM models are clickable by default), `{z}/{x}/{y}` tile URLs load as tiles instead of failing, legends generate automatically, and `classifyBy` now works in React.
+- **`snap="false"` and `clip="false"` now opt a layer out**, matching what validation already accepted; `snap="off"` / `clip="off"` unchanged.
+
 ## 0.6.13 — 2026-08-20
 
 ### Fixed

package/dist/{LercDecode.es-DB1mYTrm.js → LercDecode.es-BWmtr6fp.js}

@@ -19,7 +19,7 @@ async function v(N = {}) {
   if (n) {
     const { createRequire: I } = await import(
       /*webpackIgnore:true*/
-      "./lerc-B1LFm9ra.js"
+      "./lerc-Cw1YMyb0.js"
     ).then((g) => g._);
     var O = I(import.meta.url);
   }

package/dist/attribute-resolution.d.ts

@@ -34,6 +34,8 @@ export declare const FILTER_ATTRS: Set<string>;
  * `PathStyleExtension` (already bundled for DataFilterExtension), which only
  * applies to layers that stroke a path.
  */
+/** `data-emit`-style attribute name → camelCase (shared by om-map's payload reads and om-story's step parsing — both DOM-lane, one regex). */
+export declare function kebabToCamel(name: string): string;
 export declare const DASH_ATTRS: Set<string>;
 /** Classified symbology (spec: issue #12; src/classify.ts) — universal layer attributes like `filter-*`, resolved where the data is in hand (parse-manifest / descriptorToIR), never per-schema deck props. */
 export declare const CLASSIFY_ATTRS: Set<string>;

package/dist/{basemap-CDp9EsvL.js → basemap-DQeUv-pk.js}

@@ -1,4 +1,4 @@
-import { C as ny, L as sy, M as oy, m as ay, c as ka, z as oc, a as Sd, G as sm, V as ly, W as cy, b as uy, g as hy, d as Vu, f as Ed, e as dy, l as py, u as fy, D as Qf, h as my } from "./index-CnKC1yuV.js";
+import { C as ny, L as sy, M as oy, m as ay, c as ka, z as oc, a as Sd, G as sm, V as ly, W as cy, b as uy, g as hy, d as Vu, f as Ed, e as dy, l as py, u as fy, D as Qf, h as my } from "./index-Bnkk4jcp.js";
 const Cd = Math.PI / 180, gy = 180 / Math.PI;
 function em(Pe, Q = 0) {
   const me = Math.min(180, Pe) * Cd;

package/dist/clip-box-controller.d.ts

@@ -44,7 +44,7 @@ export declare class ClipBoxController {
      * `syncVisuals()` so `handleGizmoDrag` can drive this every mousemove
      * frame from its own LOCAL `grab.liveBox` without going anywhere near
      * `core.setClipBox`/DOM attributes (see that method's own doc comment).
-     * `patchAnimatedProps` alone is cheap and frame-rate-safe; this is the
+     * `patchAnimatedProps` is cheap and frame-rate-safe (patches within one JS turn coalesce into a single scene rebuild); this is the
      * same reason `measure-controller.ts`'s volume gizmo redraws through
      * `patchAnimatedProps` on every drag frame instead of writing anything
      * to the DOM until the gesture actually ends.

package/dist/clip-box.d.ts

@@ -1,35 +1,3 @@
-/**
- * Clip box (spec: issue #34 §"Cutting / Clipping", tier 2 — the geometric
- * complement to issue #26's clip PLANE). A real oriented... well, AXIS-
- * ALIGNED (v1 scope, confirmed explicitly — rotation is a documented
- * follow-up, not this) 3D box: geometry outside it is discarded (or, in
- * `highlight` mode, dimmed rather than removed — "non-destructive"), so a
- * dense scene (a BIM model, a point cloud, a city block) can be cut open to
- * see what's inside.
- *
- * Map-level scene state (spec: `<om-map clip-box-min="..." clip-box-max="..."
- * clip-box-invert clip-box-highlight>`), same architecture as `lighting`/
- * `terrain`: attribute-backed, undoable, live-editable, applied to every
- * layer by default with a per-layer `clip="off"` escape hatch — see
- * `applyClipBox`'s own doc comment for why that default (not opt-in) is
- * the right one here specifically.
- *
- * Three corrections from the original design review, all reflected below:
- * 1. "Outside the box" is `!inside` (De Morgan's law on the AND of 6
- *    half-spaces) — NOT a literal OR of 6 flipped half-space tests, which
- *    would (incorrectly) require re-deriving 6 new inequalities; negating
- *    the single boolean `inside` result is simpler and exactly equivalent.
- * 2. Plane/box bounds are expressed in deck's COMMON SPACE (via
- *    `Layer#projectPosition`, the SAME mechanism the built-in `ClipExtension`
- *    uses for its own 2D bounds) — never raw lng/lat — so one authored box
- *    clips layers in different coordinate systems (geographic, meter-offset
- *    BIM placements, etc.) correctly.
- * 3. Picking (including the `pickable:'3d'` depth pass) is covered for
- *    free: `discard` inside `fs:DECKGL_FILTER_COLOR` is the SAME shader
- *    stage deck's own picking pass reuses — no separate picking-specific
- *    code needed, confirmed by the built-in `ClipExtension` doing nothing
- *    extra for picking either.
- */
 import { LayerExtension } from "@deck.gl/core";
 import type { Layer } from "@deck.gl/core";
 import type { LayerIR } from "./ir";

package/dist/data-layer.d.ts

@@ -1,20 +1,3 @@
-/**
- * Data Layer (spec: "Module Breakdown / Data Layer").
- * Fetches the `data` attribute URL and caches the parsed response by URL, or
- * (Phase 3) reads inline JSON from a child `<script type="application/json">`
- * synchronously with no fetch/cache involved. Full request-generation/
- * AbortController handling (Q6: "Async data loading & the reconcile race") is
- * still a minimal, safe subset here — a per-URL fetch generation so a
- * superseded request can't clobber a newer one — not the full machinery.
- *
- * Columnar (spec: "Columnar / GeoArrow Ingestion"): the Data Layer is where
- * columnar sources become `ColumnarData` — Arrow IPC files (`.arrow`,
- * lazy-importing apache-arrow so it never weighs on the eager bundle) and
- * column-oriented JSON (`{ columns: { field: [...] } }`, inline or fetched).
- * Columnar data is handed to deck.gl as-is (zero row materialization on the
- * render path); row objects are materialized lazily and memoized only when
- * a row-consuming surface (ctx.data, picking, highlight-by-id) asks.
- */
 import type { Shape, ColumnarData, LayerData } from "./ir";
 export declare function isColumnar(data: LayerData): data is ColumnarData;
 /** `Array` as-is, or a FeatureCollection's `.features`, or a lone object wrapped in an array. */

package/dist/effects.d.ts

@@ -13,6 +13,7 @@ import type { RuntimeCore } from "./runtime-core";
 export declare function traceProgress(t01: number, t0: number, t1: number): number;
 /** Oscillates 1 → low → 1 per cycle (cosine), ending exactly at 1 for whole cycles. */
 export declare function pulseOpacity(t01: number, cycles: number, low?: number): number;
+export declare function prefersReducedMotion(): boolean;
 export interface LayerEffect {
     /** t01 ∈ [0, 1] → the plain-prop patch for this frame. */
     frame(t01: number): Record<string, unknown>;

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

@@ -1,22 +1,3 @@
-/**
- * <om-map> — spec: "Manifest Format / Core elements", "Architecture Layers",
- * "Runtime Context API", "Reactivity — the watch declaration".
- * Light DOM (spec: "DOM Model — Shadow vs. Light"): hosts the deck.gl canvas
- * (inside an internal mount div) and the <om-layer>/<om-widget> children
- * as normal siblings.
- *
- * Reconciler: full reparse per reconcile (still no diff-skipping of unchanged
- * DOM — accessor-level memoization/fingerprinting does the real work, see
- * attribute-resolution.ts / runtime-core.ts), microtask-batched (spec:
- * "MutationObserver burst batching") so N mutations in one synchronous burst
- * collapse into a single reconcile. No basemap adapter yet (Phase 6).
- *
- * Phase 4: also the widget pub-sub hub — maintains the live layer-IR
- * registry (for ctx.layers/data/stats), the current selection, and notifies
- * registered widgets per their `watch` tokens (spec: "Reactivity"). This
- * internal registration API (registerWidgetInternal/unregisterWidgetInternal/
- * emit) is consumed by OmWidgetElement, not part of the public package API.
- */
 import { HTMLElementBase } from "../env";
 import { type RuntimeContext } from "../ctx";
 import { type LightingIR } from "../scene-lighting";
@@ -73,7 +54,6 @@ export declare class OmMapElement extends HTMLElementBase {
     /** 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. */
     private internals;
     private resolveReady;

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

@@ -1,21 +1,3 @@
-/**
- * <om-story> — the storyboard element (spec: "Map Stories"). A story is a
- * time-sequenced action dispatcher: where <om-behavior> maps event →
- * action, a story maps time → action, through the exact same action-payload
- * contract (mapEl.emit). It owns the clock; nothing owns the story — the
- * player widget is optional chrome that emits story-play/pause/seek.
- *
- * Composability guarantee (spec): steps reference layers/overlays by id and
- * never contain them; delete the story and the map is byte-for-byte the
- * same map.
- *
- * Scrub model (spec, v1): seek(T) = restore captured initial state, then
- * re-fire the FINAL state of every step starting ≤ T (instant — payload
- * duration overridden to 0). Step-granularity; mid-step interpolation is
- * deferred. Initial state is captured on first play from the attributes the
- * built-in-action steps will touch (statically computable from payloads)
- * plus the camera; custom-action steps are replay-only (warned once).
- */
 import { HTMLElementBase } from "../env";
 export type StoryState = "idle" | "playing" | "paused" | "ended";
 export declare class OmStoryElement extends HTMLElementBase {

package/dist/expr/errors.d.ts

@@ -8,3 +8,6 @@ export declare class CompileError extends Error {
     readonly fix: string;
     constructor(message: string, fix: string);
 }
+import type { Program } from "estree";
+/** Shared acorn container parse for both accessor-block flavors — one grammar, one error shape; only the fix hint names the block. */
+export declare function parseProgram(blockText: string, blockLabel: string): Program;

package/dist/field-access.d.ts

@@ -22,3 +22,13 @@ export declare function matchesFeatureId(row: unknown, featureId: string, shape:
  * asRows view — the Tier-2 rule, stated once here instead of at each caller.
  */
 export declare function findRowIndexById(data: LayerData, featureId: string, shape: Shape): number;
+/**
+ * Shape-less named-field read: a GeoJSON Feature's field lives under
+ * `properties`, a flat row carries it directly — probe both, `in`-checked so
+ * an explicit null/undefined stored under properties still wins. For callers
+ * that have no `Shape` in hand (the Tracking layer pair); everything with a
+ * shape should use `getField`.
+ */
+export declare function readNamedField(row: unknown, field: string): unknown;
+/** Recursively walks GeoJSON `coordinates` (Point/LineString/Polygon/Multi*) collecting every [lng, lat] vertex. */
+export declare function collectCoordinates(coordinates: unknown, out: [number, number][]): void;

package/dist/geodesy.d.ts

@@ -23,6 +23,15 @@ export type LngLat = [number, number];
 export declare function distanceMeters(a: LngLat, b: LngLat, radius?: number): number;
 /** Total haversine length of a polyline in meters (0 for < 2 points). */
 export declare function pathLengthMeters(points: LngLat[], radius?: number): number;
+/**
+ * Web Mercator ground resolution — meters per screen pixel at a latitude and
+ * zoom. The one formula four controllers used to carry inline (draw close
+ * guard, clip-box handle radius, measure hover tolerance, filter histogram).
+ * `minCosLat` clamps the cosine near the poles (the clip-box gizmo needs a
+ * floor so handle hit radii stay finite above ~84°); the default 0 keeps the
+ * exact classic formula.
+ */
+export declare function metersPerPixel(latitude: number, zoom: number, minCosLat?: number): number;
 export interface PathSample {
     position: LngLat;
     /** Cumulative distance (m) from the path's start. */
@@ -42,6 +51,8 @@ export interface PathSample {
  */
 export declare function resamplePath(points: LngLat[], count: number): PathSample[];
 export declare function resamplePathWithVertices(points: LngLat[], count: number): PathSample[];
+/** Drop a trailing vertex that duplicates the first (a closed ring → open list). */
+export declare function openRing(ring: LngLat[]): LngLat[];
 /**
  * Spherical polygon area in m² via the Chamberlain–Duquette line integral (the
  * exact index form Turf's `ringArea` uses, so results match Turf's fixtures).

package/dist/{geoparquet-CI3o8X5-.js → geoparquet-DsYXvvEo.js}

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

package/dist/{index-Dio4lUCZ.js → index-BTJy4dWy.js}

@@ -1,4 +1,4 @@
-import { ae as _t, af as Ct } from "./index-CnKC1yuV.js";
+import { ae as _t, af as Ct } from "./index-Bnkk4jcp.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);