@fundar/data-chart-telling 0.0.64 → 1.0.0

package/dist/plots/utils/segments.d.ts

@@ -1,4 +1,4 @@
-import type { AxisValue } from '../../types/layout/scales';
+import type { AxisValue } from '../../types/layout/mapping';
 import type { Series } from '../../types/plots/data/common';
 import type { LineSegmentStyle } from '../../types/plots/segments/common';
 import type { Segment, VisualGroup } from '../../types/plots/segments/config';
@@ -18,21 +18,10 @@ export declare function matchesSegmentX<TStyle>(xVal: AxisValue, seg: Segment<TS
  * and in order, only the first one can ever match; later ones are dead code.
  */
 export declare function validateSegments<TStyle>(segments: SegmentsConfig<TStyle>): void;
-/**
- * Builds the full list of visual groups — one per series — ready to render.
- * Each group's `visualSegments` is derived by resolving the flat segment list
- * for that series from all groups in `segments`.
- *
- * `connect` bridges adjacent visual segments so a *continuous* mark (line)
- * has no visual gap at their boundary — the default, since `buildGroupedSeries`
- * itself defaults `TStyle` to {@link LineSegmentStyle}. Discrete marks (bar,
- * pyramid) have no gap to bridge; pass `connect: false` so boundary rows
- * aren't duplicated as an extra, separately-styled mark.
- */
-export declare function buildGroupedSeries<S extends Series<any>, TStyle = LineSegmentStyle>(seriesList: S[], segments: SegmentsConfig<TStyle>, connect?: boolean): VisualGroup<S, TStyle>[];
+export declare function buildGroupedSeries<S extends Series<any>, TStyle = LineSegmentStyle>(seriesList: S[], segments?: SegmentsConfig<TStyle>, connect?: boolean): VisualGroup<S, TStyle>[];
 /**
  * Builds the `ScopedMarkerGroup[]` a `Plot.svelte` hands to `GeometryLayout`
- * for rendering `series`-scoped `hover`/`component` markers — one group per
+ * for rendering `series`-scoped `hover`/`component` markers - one group per
  * series, carrying its resolved segments' match predicates and colors.
  * `colorFor` resolves a series' own default color; `segmentColorFor` reads
  * whichever field counts as "color" out of that plot kind's segment style
@@ -41,7 +30,7 @@ export declare function buildGroupedSeries<S extends Series<any>, TStyle = LineS
  */
 export declare function buildScopedMarkerGroups<TData extends Record<string, unknown>, S extends Series<any>, TStyle>(args: {
     groupedSeries: VisualGroup<S, TStyle>[];
-    segments: SegmentsConfig<TStyle>;
+    segments?: SegmentsConfig<TStyle>;
     colorFor: (series: S, seriesIndex: number) => string;
-    segmentColorFor: (style: TStyle | undefined, defaultColor: string) => string;
+    segmentColorFor: (styles: TStyle | undefined, defaultColor: string) => string;
 }): ScopedMarkerGroup<TData>[];

package/dist/plots/utils/segments.js

@@ -1,4 +1,5 @@
 import { resolveAccessor } from './accessors';
+import { merge } from '../../utils/merge';
 const DEFAULT_KEY = 'default';
 /**
  * Returns the flat {@link Segment} list for one series.
@@ -17,24 +18,22 @@ export function matchesSegmentX(xVal, seg) {
         return true;
     return areas.some((area) => areaMatchesX(xVal, area));
 }
+/* eslint-disable @typescript-eslint/no-explicit-any -- axis values compare across number, string and Date */
 function areaMatchesX(xVal, area) {
     if (!area.x)
         return true;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return (area.x.from === undefined || xVal >= area.x.from) &&
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        (area.x.to === undefined || xVal <= area.x.to);
+    return ((area.x.from === undefined || xVal >= area.x.from) &&
+        (area.x.to === undefined || xVal <= area.x.to));
 }
 function areaMatchesXY(xVal, yVal, area) {
     if (!areaMatchesX(xVal, area))
         return false;
     if (!area.y)
         return true;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return (area.y.from === undefined || yVal >= area.y.from) &&
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        (area.y.to === undefined || yVal <= area.y.to);
+    return ((area.y.from === undefined || yVal >= area.y.from) &&
+        (area.y.to === undefined || yVal <= area.y.to));
 }
+/* eslint-enable @typescript-eslint/no-explicit-any */
 /**
  * Warns about obvious configuration mistakes: multiple catch-all segments
  * (no `areas`) in the same series list. Since catch-alls are evaluated last
@@ -44,7 +43,7 @@ export function validateSegments(segments) {
     const check = (label, segs) => {
         const catchAlls = segs.filter((s) => !s.areas || s.areas.length === 0).length;
         if (catchAlls > 1) {
-            console.warn(`segments ${label}: ${catchAlls} entries have no areas — ` +
+            console.warn(`segments ${label}: ${catchAlls} entries have no areas - ` +
                 `only the first catch-all's style will be used.`);
         }
     };
@@ -52,34 +51,13 @@ export function validateSegments(segments) {
         check(key === DEFAULT_KEY ? '(default)' : `"${key}"`, segs);
     }
 }
-function isPlainObject(v) {
-    return v !== null && typeof v === 'object' && !Array.isArray(v);
-}
-/**
- * Merges two style objects one level deep: for any key where both base and
- * override hold plain objects (e.g. `stroke`, `dots`), their fields are
- * merged — override wins on conflict. Primitive fields are overridden directly.
- */
-function mergeStyles(base, override) {
-    const result = { ...base };
-    for (const [key, val] of Object.entries(override)) {
-        const baseVal = result[key];
-        if (isPlainObject(val) && isPlainObject(baseVal)) {
-            result[key] = { ...baseVal, ...val };
-        }
-        else {
-            result[key] = val;
-        }
-    }
-    return result;
-}
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function resolveSeriesSegments(series, segs, connect) {
     if (!segs.length) {
-        return [{ data: series.data, style: {} }];
+        return [{ data: series.data, styles: {}, scales: undefined }];
     }
-    const getX = resolveAccessor(series.x);
-    const getY = resolveAccessor(series.y);
+    const getX = readChannel(series.x);
+    const getY = readChannel(series.y);
     // Evaluate area-specific segments before catch-alls (no areas), preserving
     // relative order within each group. This lets a catch-all placed first in
     // the list act as a fallback baseline rather than matching everything.
@@ -120,9 +98,10 @@ function resolveSeriesSegments(series, segs, connect) {
     // Dots are excluded to avoid duplicate marks at the shared boundary points.
     const catchAll = segs.find((s) => !s.areas || s.areas.length === 0);
     const connectorStyle = (() => {
-        if (!catchAll?.style)
+        if (!catchAll?.styles)
             return {};
-        const { dots: _, ...rest } = catchAll.style;
+        const rest = { ...catchAll.styles };
+        delete rest.dots;
         return rest;
     })();
     const defaultVisual = [];
@@ -133,7 +112,7 @@ function resolveSeriesSegments(series, segs, connect) {
         if (run.segIdx === -1) {
             // Unmatched run: for a continuous mark (line), insert bridge points so
             // it connects to adjacent user segments without a visual gap. Discrete
-            // marks (bar, pyramid) have no such gap to bridge — bridging would just
+            // marks (bar, pyramid) have no such gap to bridge - bridging would just
             // duplicate the neighboring runs' boundary rows as an extra, wrongly
             // styled mark at that same category.
             const bridged = [...run.data];
@@ -143,29 +122,31 @@ function resolveSeriesSegments(series, segs, connect) {
                 if (r < runs.length - 1)
                     bridged.push(runs[r + 1].data[0]);
             }
-            defaultVisual.push({ data: bridged, style: {} });
+            defaultVisual.push({ data: bridged, styles: {}, scales: undefined });
         }
         else {
             const seg = segs[run.segIdx];
-            const segStyle = seg.style ?? {};
+            const segStyle = seg.styles ?? {};
             // Area-specific segments merge the catch-all as a baseline: catch-all
             // keys fill in whatever the area segment omits; the area wins on conflict.
             const isAreaSpecific = seg.areas != null && seg.areas.length > 0;
-            const resolvedStyle = isAreaSpecific && catchAll?.style
-                ? mergeStyles(catchAll.style, segStyle)
+            const resolvedStyle = isAreaSpecific && catchAll?.styles
+                ? merge(catchAll.styles, segStyle)
                 : segStyle;
-            userVisual.push({ data: run.data, style: resolvedStyle });
+            const resolvedScales = seg.scales ?? (isAreaSpecific && catchAll?.scales ? catchAll.scales : undefined);
+            userVisual.push({ data: run.data, styles: resolvedStyle, scales: resolvedScales });
             // When the next run is also a user segment (no unmatched data between them),
             // insert a line-only connector so the lines join without a gap. Using a
             // separate mark (rather than appending a bridge point to the current run)
             // avoids rendering an extra dot at the shared boundary point. Skipped
-            // entirely for discrete marks (see above) — it would duplicate both
+            // entirely for discrete marks (see above) - it would duplicate both
             // runs' boundary rows as an extra mark.
             const nextRun = runs[r + 1];
             if (connect && nextRun && nextRun.segIdx !== -1) {
                 connectors.push({
                     data: [run.data[run.data.length - 1], nextRun.data[0]],
-                    style: connectorStyle,
+                    styles: connectorStyle,
+                    scales: undefined
                 });
             }
         }
@@ -177,25 +158,30 @@ function resolveSeriesSegments(series, segs, connect) {
     return [...defaultVisual, ...connectors, ...userVisual];
 }
 /**
- * Builds the full list of visual groups — one per series — ready to render.
+ * Builds the full list of visual groups - one per series - ready to render.
  * Each group's `visualSegments` is derived by resolving the flat segment list
  * for that series from all groups in `segments`.
  *
  * `connect` bridges adjacent visual segments so a *continuous* mark (line)
- * has no visual gap at their boundary — the default, since `buildGroupedSeries`
+ * has no visual gap at their boundary - the default, since `buildGroupedSeries`
  * itself defaults `TStyle` to {@link LineSegmentStyle}. Discrete marks (bar,
  * pyramid) have no gap to bridge; pass `connect: false` so boundary rows
  * aren't duplicated as an extra, separately-styled mark.
  */
-export function buildGroupedSeries(seriesList, segments, connect = true) {
+/** A position channel's accessor, reading nothing when the series doesn't set it. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function readChannel(accessor) {
+    return accessor === undefined ? () => undefined : resolveAccessor(accessor);
+}
+export function buildGroupedSeries(seriesList, segments = {}, connect = true) {
     return seriesList.map((s) => ({
         series: s,
-        visualSegments: resolveSeriesSegments(s, resolveSegmentsForSeries(segments, s.name), connect),
+        visualSegments: resolveSeriesSegments(s, resolveSegmentsForSeries(segments, s.name), connect)
     }));
 }
 /**
  * Builds the `ScopedMarkerGroup[]` a `Plot.svelte` hands to `GeometryLayout`
- * for rendering `series`-scoped `hover`/`component` markers — one group per
+ * for rendering `series`-scoped `hover`/`component` markers - one group per
  * series, carrying its resolved segments' match predicates and colors.
  * `colorFor` resolves a series' own default color; `segmentColorFor` reads
  * whichever field counts as "color" out of that plot kind's segment style
@@ -203,19 +189,21 @@ export function buildGroupedSeries(seriesList, segments, connect = true) {
  * that isn't shared across plot kinds.
  */
 export function buildScopedMarkerGroups(args) {
-    const { groupedSeries, segments, colorFor, segmentColorFor } = args;
+    const { groupedSeries, segments = {}, colorFor, segmentColorFor } = args;
     return groupedSeries.map((group, seriesIndex) => {
         const defaultColor = colorFor(group.series, seriesIndex);
-        const xFor = resolveAccessor(group.series.x);
+        const xFor = readChannel(group.series.x);
         const segs = resolveSegmentsForSeries(segments, group.series.name);
         return {
             name: group.series.name,
+            ...(group.series.id !== undefined ? { id: group.series.id } : {}),
+            ...(group.series.panel !== undefined ? { panel: group.series.panel } : {}),
             data: group.series.data,
             color: defaultColor,
             segments: segs.map((seg) => ({
                 match: (row) => matchesSegmentX(xFor(row), seg),
-                color: segmentColorFor(seg.style, defaultColor),
-            })),
+                color: segmentColorFor(seg.styles, defaultColor)
+            }))
         };
     });
 }

package/dist/plots/utils/tiles.d.ts

@@ -14,7 +14,7 @@ export type ProjectionLike = {
     (point: [number, number]): [number, number] | null;
     invert?(point: [number, number]): [number, number] | null;
 };
-/** The minimal geometry-stream shape a projection's `.stream()` accepts — kept local instead of importing `d3-geo`'s own `GeoStream` type, so this module stays dependency-free. */
+/** The minimal geometry-stream shape a projection's `.stream()` accepts - kept local instead of importing `d3-geo`'s own `GeoStream` type, so this module stays dependency-free. */
 type MinimalStream = {
     point: (x: number, y: number, z?: number) => void;
     lineStart: () => void;
@@ -30,7 +30,7 @@ export type StreamingProjection = {
 };
 /**
  * Adapts a svelteplot-resolved projection (which exposes `.stream()`/
- * `.invert()`, but — unlike a raw `d3-geo` projection instance — isn't
+ * `.invert()`, but - unlike a raw `d3-geo` projection instance - isn't
  * itself callable as `(point) => [x, y]`) into a `ProjectionLike`, by
  * feeding a single point through its stream pipeline and capturing the
  * projected output.
@@ -39,7 +39,7 @@ export declare function toProjectionLike(projection: StreamingProjection): Proje
 /**
  * Derives the visible XYZ tile grid from svelteplot's own already-fitted
  * projection (rather than this package computing/duplicating a `d3-geo` fit
- * itself) — see `TileLayer.svelte`. Only correct for Mercator-family
+ * itself) - see `TileLayer.svelte`. Only correct for Mercator-family
  * projections, where a screen-space rectangle maps back to a lon/lat bbox
  * whose tile coverage is well-defined; callers are responsible for the
  * projection-compatibility check (see `Plot.svelte`'s validation effect).
@@ -57,8 +57,8 @@ export type MercatorFit = {
 };
 /**
  * Builds an affine tile-space → screen-space mapping from two reliable
- * anchor points — `bounds`' own top-left/bottom-right corners, inverted
- * back to lon/lat — rather than forward-projecting each tile's own corners
+ * anchor points - `bounds`' own top-left/bottom-right corners, inverted
+ * back to lon/lat - rather than forward-projecting each tile's own corners
  * individually (what this replaced). That per-tile approach broke under a
  * projection whose scale/translate were fit to a *custom* domain rather
  * than set via its own `.scale()`/`.translate()`: `d3-geo`'s cylindrical
@@ -68,21 +68,21 @@ export type MercatorFit = {
  * blowup near the poles); svelteplot's own domain-fitting wraps the
  * *unmodified* projection instance in an external transform instead of
  * calling those setters, so that internal clip keeps silently rejecting
- * forward-projected points outside its stale bounds — nulling out most of
+ * forward-projected points outside its stale bounds - nulling out most of
  * a tile grid even for tiles nowhere near a pole. `.invert()` isn't routed
  * through that clip, so anchoring to two known-good inverted corners
- * sidesteps it entirely — sound because Mercator's tile space (longitude,
+ * sidesteps it entirely - sound because Mercator's tile space (longitude,
  * and the standard log-tan latitude transform used by `latToTileY`) is
  * affine in screen space by construction, so one linear fit applies
  * uniformly to every tile in the grid.
  */
 export declare function buildMercatorFit(projection: ProjectionLike, rawBounds: ScreenBounds, z: number, dataLonLatBounds?: [number, number, number, number] | null): MercatorFit | null;
-/** Places a tile on screen via a `MercatorFit` — `null` only if `tile` is from a different zoom level than the fit was built for. */
+/** Places a tile on screen via a `MercatorFit` - `null` only if `tile` is from a different zoom level than the fit was built for. */
 export declare function tileScreenBounds(fit: MercatorFit, tile: TileCoord): ScreenBounds | null;
 /**
  * Fills `{z}/{x}/{y}` placeholders in a tile URL template. Also supports
  * `{-y}` for TMS-scheme sources (e.g. IGN's tile services), whose row index
- * counts from the south instead of the north — the standard XYZ-to-TMS
+ * counts from the south instead of the north - the standard XYZ-to-TMS
  * conversion `2^z - 1 - y`.
  */
 export declare function tileUrl(template: string, tile: TileCoord): string;

package/dist/plots/utils/tiles.js

@@ -1,6 +1,6 @@
 /**
  * Adapts a svelteplot-resolved projection (which exposes `.stream()`/
- * `.invert()`, but — unlike a raw `d3-geo` projection instance — isn't
+ * `.invert()`, but - unlike a raw `d3-geo` projection instance - isn't
  * itself callable as `(point) => [x, y]`) into a `ProjectionLike`, by
  * feeding a single point through its stream pipeline and capturing the
  * projected output.
@@ -15,7 +15,7 @@ export function toProjectionLike(projection) {
             lineStart() { },
             lineEnd() { },
             polygonStart() { },
-            polygonEnd() { },
+            polygonEnd() { }
         };
         projection.stream(sink).point(point[0], point[1]);
         return result;
@@ -33,7 +33,7 @@ function latToTileY(lat, z) {
 }
 /**
  * Picks an integer XYZ zoom level whose tile pixel density roughly matches
- * the projection's *current* pixels-per-degree at the map center — so tiles
+ * the projection's *current* pixels-per-degree at the map center - so tiles
  * neither look blurry (too coarse) nor waste bandwidth (too fine).
  */
 function estimateZoomLevel(projection, centerLon, centerLat, tileSize) {
@@ -73,28 +73,28 @@ function clampBoundsToWorld(projection, bounds) {
 }
 /**
  * How far a letterboxed tile margin may reach beyond the data's own
- * bounding box (see `Plot.svelte`'s `dataLonLatBounds`), on either side —
+ * bounding box (see `Plot.svelte`'s `dataLonLatBounds`), on either side -
  * the product-level cap on how much basemap "context" gets shown, well
  * inside `clampBoundsToWorld`'s own (much looser) antimeridian-safety cap.
  *
  * Picked to comfortably clear the nearest *other* landmass in any direction
- * from Argentina — this package's one real-world `domain: 'data'` +
+ * from Argentina - this package's one real-world `domain: 'data'` +
  * tile-layer consumer. The tightest real constraint is the Atlantic side:
  * Argentina's own east edge sits at -53°, and the nearest land across it
- * (West Africa) starts around -17° — a 36°-wide ocean gap. A flat 20° here
+ * (West Africa) starts around -17° - a 36°-wide ocean gap. A flat 20° here
  * stays comfortably inside that gap on the tight side, while every other
  * direction (west into the Pacific, especially) has far more real ocean to
  * spare than this uses.
  */
 const CONTEXT_PADDING_DEGREES = 20;
 /**
- * A raster tile is atomic — one straddling the padding boundary above still
+ * A raster tile is atomic - one straddling the padding boundary above still
  * renders in full, so at a low enough zoom a single tile can overshoot
  * `CONTEXT_PADDING_DEGREES` by tens of degrees (confirmed empirically: a
- * small facet cell naturally estimates z≈1–2, where a tile is 90°–180°
+ * small facet cell naturally estimates z≈1-2, where a tile is 90°-180°
  * wide, dragging in all of Africa well past the intended padding). Flooring
  * the zoom to at least this, whenever `clampBoundsToDataPadding` actually
- * reduced the bounds, guarantees a tile is at most 360/2⁶ = 5.625° wide —
+ * reduced the bounds, guarantees a tile is at most 360/2⁶ = 5.625° wide -
  * comfortably under half of `CONTEXT_PADDING_DEGREES`, so the worst-case
  * overshoot still lands well short of real land.
  */
@@ -102,10 +102,10 @@ const MIN_ZOOM_WHEN_CONTEXT_CLAMPED = 6;
 /**
  * Clamps `bounds`' horizontal extent to the data's own lon/lat bbox padded
  * by `CONTEXT_PADDING_DEGREES` on each side, at the box's own center
- * latitude — a no-op when `dataLonLatBounds` isn't supplied (a plot with no
+ * latitude - a no-op when `dataLonLatBounds` isn't supplied (a plot with no
  * tile-layer-relevant data footprint, e.g. not a `domain: 'data'` fit; see
  * `Plot.svelte`'s `usesDataFit`). Independent of, and applied on top of,
- * `clampBoundsToWorld`'s own antimeridian-safety cap — that cap alone still
+ * `clampBoundsToWorld`'s own antimeridian-safety cap - that cap alone still
  * permits up to a quarter-turn of the globe each way, comfortably reaching
  * an unrelated continent instead of just nearby ocean (see `GeoPlot/Facet`
  * stories' `Rows2Cols2` for the regression this fixes).
@@ -114,7 +114,10 @@ function clampBoundsToDataPadding(projection, bounds, dataLonLatBounds) {
     if (!dataLonLatBounds || !projection.invert)
         return bounds;
     const [minLon, , maxLon] = dataLonLatBounds;
-    const centerLonLat = projection.invert([bounds.left + bounds.width / 2, bounds.top + bounds.height / 2]);
+    const centerLonLat = projection.invert([
+        bounds.left + bounds.width / 2,
+        bounds.top + bounds.height / 2
+    ]);
     if (!centerLonLat)
         return bounds;
     const west = projection([minLon - CONTEXT_PADDING_DEGREES, centerLonLat[1]]);
@@ -130,7 +133,7 @@ function clampBoundsToDataPadding(projection, bounds, dataLonLatBounds) {
 /**
  * Derives the visible XYZ tile grid from svelteplot's own already-fitted
  * projection (rather than this package computing/duplicating a `d3-geo` fit
- * itself) — see `TileLayer.svelte`. Only correct for Mercator-family
+ * itself) - see `TileLayer.svelte`. Only correct for Mercator-family
  * projections, where a screen-space rectangle maps back to a lon/lat bbox
  * whose tile coverage is well-defined; callers are responsible for the
  * projection-compatibility check (see `Plot.svelte`'s validation effect).
@@ -144,13 +147,20 @@ export function visibleTiles(projection, rawBounds, tileSize = 256, minZoom = 0,
         [bounds.left, bounds.top],
         [bounds.left + bounds.width, bounds.top],
         [bounds.left, bounds.top + bounds.height],
-        [bounds.left + bounds.width, bounds.top + bounds.height],
+        [bounds.left + bounds.width, bounds.top + bounds.height]
     ];
-    const lonLats = corners.map((c) => projection.invert(c)).filter((p) => p != null);
+    const lonLats = corners
+        .map((c) => projection.invert(c))
+        .filter((p) => p != null);
     if (lonLats.length === 0)
         return [];
-    const effectiveMinZoom = contextClamped ? Math.max(minZoom, MIN_ZOOM_WHEN_CONTEXT_CLAMPED) : minZoom;
-    const centerScreen = [bounds.left + bounds.width / 2, bounds.top + bounds.height / 2];
+    const effectiveMinZoom = contextClamped
+        ? Math.max(minZoom, MIN_ZOOM_WHEN_CONTEXT_CLAMPED)
+        : minZoom;
+    const centerScreen = [
+        bounds.left + bounds.width / 2,
+        bounds.top + bounds.height / 2
+    ];
     const center = projection.invert(centerScreen);
     const z = center
         ? Math.max(effectiveMinZoom, Math.min(maxZoom, estimateZoomLevel(projection, center[0], center[1], tileSize) ?? effectiveMinZoom))
@@ -172,8 +182,8 @@ export function visibleTiles(projection, rawBounds, tileSize = 256, minZoom = 0,
 }
 /**
  * Builds an affine tile-space → screen-space mapping from two reliable
- * anchor points — `bounds`' own top-left/bottom-right corners, inverted
- * back to lon/lat — rather than forward-projecting each tile's own corners
+ * anchor points - `bounds`' own top-left/bottom-right corners, inverted
+ * back to lon/lat - rather than forward-projecting each tile's own corners
  * individually (what this replaced). That per-tile approach broke under a
  * projection whose scale/translate were fit to a *custom* domain rather
  * than set via its own `.scale()`/`.translate()`: `d3-geo`'s cylindrical
@@ -183,10 +193,10 @@ export function visibleTiles(projection, rawBounds, tileSize = 256, minZoom = 0,
  * blowup near the poles); svelteplot's own domain-fitting wraps the
  * *unmodified* projection instance in an external transform instead of
  * calling those setters, so that internal clip keeps silently rejecting
- * forward-projected points outside its stale bounds — nulling out most of
+ * forward-projected points outside its stale bounds - nulling out most of
  * a tile grid even for tiles nowhere near a pole. `.invert()` isn't routed
  * through that clip, so anchoring to two known-good inverted corners
- * sidesteps it entirely — sound because Mercator's tile space (longitude,
+ * sidesteps it entirely - sound because Mercator's tile space (longitude,
  * and the standard log-tan latitude transform used by `latToTileY`) is
  * affine in screen space by construction, so one linear fit applies
  * uniformly to every tile in the grid.
@@ -212,10 +222,10 @@ export function buildMercatorFit(projection, rawBounds, z, dataLonLatBounds) {
         tileXAtLeft,
         tileYAtTop,
         pxPerTileX: bounds.width / (tileXAtRight - tileXAtLeft),
-        pxPerTileY: bounds.height / (tileYAtBottom - tileYAtTop),
+        pxPerTileY: bounds.height / (tileYAtBottom - tileYAtTop)
     };
 }
-/** Places a tile on screen via a `MercatorFit` — `null` only if `tile` is from a different zoom level than the fit was built for. */
+/** Places a tile on screen via a `MercatorFit` - `null` only if `tile` is from a different zoom level than the fit was built for. */
 export function tileScreenBounds(fit, tile) {
     if (tile.z !== fit.z)
         return null;
@@ -223,13 +233,13 @@ export function tileScreenBounds(fit, tile) {
         left: fit.screenLeft + (tile.x - fit.tileXAtLeft) * fit.pxPerTileX,
         top: fit.screenTop + (tile.y - fit.tileYAtTop) * fit.pxPerTileY,
         width: fit.pxPerTileX,
-        height: fit.pxPerTileY,
+        height: fit.pxPerTileY
     };
 }
 /**
  * Fills `{z}/{x}/{y}` placeholders in a tile URL template. Also supports
  * `{-y}` for TMS-scheme sources (e.g. IGN's tile services), whose row index
- * counts from the south instead of the north — the standard XYZ-to-TMS
+ * counts from the south instead of the north - the standard XYZ-to-TMS
  * conversion `2^z - 1 - y`.
  */
 export function tileUrl(template, tile) {

package/dist/plots/utils/topojson.d.ts

@@ -3,7 +3,7 @@ export declare function isTopology(data: unknown): data is Topology;
 /**
  * Converts a TopoJSON `Topology` to GeoJSON via `topojson-client`'s
  * `feature()`, loaded with a dynamic import so the package works perfectly
- * for consumers who never install `topojson-client` — it's an optional peer
+ * for consumers who never install `topojson-client` - it's an optional peer
  * dependency (see package.json), never statically imported.
  */
 export declare function topologyToGeoJson<TProps extends Record<string, unknown>>(topology: Topology, object: string): Promise<GeoFeature<TProps>[]>;

package/dist/plots/utils/topojson.js

@@ -4,7 +4,7 @@ export function isTopology(data) {
 /**
  * Converts a TopoJSON `Topology` to GeoJSON via `topojson-client`'s
  * `feature()`, loaded with a dynamic import so the package works perfectly
- * for consumers who never install `topojson-client` — it's an optional peer
+ * for consumers who never install `topojson-client` - it's an optional peer
  * dependency (see package.json), never statically imported.
  */
 export async function topologyToGeoJson(topology, object) {
@@ -14,7 +14,7 @@ export async function topologyToGeoJson(topology, object) {
     }
     let mod;
     try {
-        // @ts-expect-error — topojson-client is an optional peer dependency; its
+        // @ts-expect-error - topojson-client is an optional peer dependency; its
         // type declarations are intentionally not resolved by our own build
         // (`Topology` above is typed structurally instead), so this import is
         // resolved purely at runtime.
@@ -22,7 +22,7 @@ export async function topologyToGeoJson(topology, object) {
     }
     catch {
         throw new Error("GeoPlot: `data` is a TopoJSON Topology, but 'topojson-client' isn't installed. " +
-            'Run `npm install topojson-client` (it\'s an optional peer dependency) or pass GeoJSON directly.');
+            "Run `npm install topojson-client` (it's an optional peer dependency) or pass GeoJSON directly.");
     }
     const { feature } = mod;
     const collection = feature(topology, obj);

package/dist/stores/device.js

@@ -30,10 +30,8 @@ const viewport = readable({ width: 0, height: 0 }, (set) => {
     };
 });
 export const isMobile = derived(viewport, ($viewport) => $viewport.width < 768);
-export const isTablet = derived(viewport, ($viewport) => ($viewport.width >= 768 &&
-    $viewport.width < 1024));
-export const isLaptop = derived(viewport, ($viewport) => ($viewport.width >= 1024 &&
-    $viewport.width < 1280));
+export const isTablet = derived(viewport, ($viewport) => $viewport.width >= 768 && $viewport.width < 1024);
+export const isLaptop = derived(viewport, ($viewport) => $viewport.width >= 1024 && $viewport.width < 1280);
 export const isDesktop = derived(viewport, ($viewport) => $viewport.width >= 1280);
 export const viewportWidth = derived(viewport, ($viewport) => $viewport.width);
 export const viewportHeight = derived(viewport, ($viewport) => $viewport.height);