@fundar/data-chart-telling 1.0.0 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fundar/data-chart-telling",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Declarative charts, maps and small multiples for Svelte, built on svelteplot.",
   "license": "MIT",
   "author": "Ezequiel Puerta",
@@ -26,6 +26,14 @@
     "docs",
     "!docs/images",
     "examples",
+    "!examples/geo",
+    "!examples/datasets/amba-partidos.ts",
+    "!examples/datasets/argentina-provinces.ts",
+    "!examples/datasets/caba-comunas.ts",
+    "!examples/datasets/napoleons-rivers.ts",
+    "!examples/datasets/usa-country.ts",
+    "!examples/datasets/world-countries.ts",
+    "!examples/datasets/world-countries-topology.ts",
     "llms.txt",
     "llms-full.txt"
   ],
@@ -120,9 +128,11 @@
     "format": "prettier --write .",
     "test": "vitest run --project=unit --project=browser",
     "test:coverage": "node scripts/coverage.mjs",
+    "test:perf": "vitest run --project=perf --reporter=verbose",
     "test:stories": "vitest run --project=storybook",
     "storybook": "storybook dev -p 6006",
     "build-storybook": "storybook build",
-    "docs:images": "node scripts/docs-images.mjs"
+    "docs:images": "node scripts/docs-images.mjs",
+    "docs:examples": "node scripts/sync-examples.mjs"
   }
 }

package/dist/layout/scales/buildScale.d.ts

@@ -1,8 +0,0 @@
-import type { AxisScale } from '../../types/layout/scales';
-import type { AxisValue } from '../../types/layout/mapping';
-/**
- * An {@link AxisScale} as svelteplot's `<Plot x>`/`<Plot y>` accepts it: without
- * `grid`, `axisDisplay` and a vertical `label`, which `ScalesLayout` draws, and
- * with `nice: true` on an unpinned numeric axis.
- */
-export declare function buildScale<TData>(scale: AxisScale<TData> | undefined, rows: TData[], getAxisValue: (d: TData) => AxisValue): AxisScale<TData> | undefined;

package/dist/layout/scales/buildScale.js

@@ -1,67 +0,0 @@
-import { SvelteSet } from 'svelte/reactivity';
-/** One representative row per unique axis value (first occurrence in `rows`). */
-function uniqueRows(rows, getAxisValue) {
-    const seen = new SvelteSet();
-    const out = [];
-    for (const row of rows) {
-        const v = getAxisValue(row);
-        if (seen.has(v))
-            continue;
-        seen.add(v);
-        out.push(row);
-    }
-    return out;
-}
-/** svelteplot's `sort` option only does a fixed ascending sort; a custom `scale.sort` comparator is resolved into an explicit `domain` instead, which svelteplot honors as-is. */
-function sortedScale(scale, rows, getAxisValue) {
-    const sort = scale?.sort;
-    if (!sort || scale?.domain)
-        return scale;
-    const reps = uniqueRows(rows, getAxisValue);
-    if (reps.length === 0 || !reps.every((r) => typeof getAxisValue(r) === 'string'))
-        return scale;
-    const domain = [...reps].sort(sort).map(getAxisValue);
-    return { ...scale, domain };
-}
-/** Scale types {@link buildScale}'s default `nice` only applies to - every other type has its own tick semantics (or isn't numeric at all). */
-const CONTINUOUS_NUMERIC_TYPES = new Set(['auto', 'linear', 'pow', 'sqrt', 'log', 'symlog']);
-/** Whether the axis' values are numeric; `nice` on a categorical axis would make svelteplot treat it as linear. */
-function isNumericAxis(rows, getAxisValue) {
-    let numericSeen = 0;
-    for (const row of rows) {
-        const v = getAxisValue(row);
-        if (v == null)
-            continue;
-        if (typeof v !== 'number')
-            return false;
-        if (++numericSeen >= 2)
-            return true;
-    }
-    return numericSeen > 0;
-}
-/**
- * An {@link AxisScale} as svelteplot's `<Plot x>`/`<Plot y>` accepts it: without
- * `grid`, `axisDisplay` and a vertical `label`, which `ScalesLayout` draws, and
- * with `nice: true` on an unpinned numeric axis.
- */
-export function buildScale(scale, rows, getAxisValue) {
-    const sorted = sortedScale(scale, rows, getAxisValue);
-    const wantsNice = scale?.domain == null &&
-        scale?.ticks == null &&
-        scale?.nice == null &&
-        (scale?.type == null || CONTINUOUS_NUMERIC_TYPES.has(scale.type)) &&
-        isNumericAxis(rows, getAxisValue);
-    const removesAxis = scale?.axisDisplay === 'none';
-    if (!sorted && !wantsNice && !removesAxis)
-        return sorted;
-    const out = { ...sorted };
-    delete out.grid;
-    delete out.axisDisplay;
-    if (removesAxis)
-        out.axis = false;
-    if (scale?.labelOrientation === 'vertical')
-        out.label = false;
-    if (wantsNice)
-        out.nice = true;
-    return out;
-}

package/dist/layout/scales/niceDomain.d.ts

@@ -1,23 +0,0 @@
-/** Step between "nice" (1/2/5×10ⁿ) tick values for an approximate `count` over `[start, stop]`. */
-export declare function tickStep(start: number, stop: number, count: number): number;
-/** Multiples of `step` covering `[start, stop]`, inclusive of either endpoint when it lands exactly on one. */
-export declare function ticksInRange(start: number, stop: number, step: number): number[];
-/** Ticks-per-axis heuristic - used by `ScalesLayout` to pick a target count from an axis's actual pixel span. */
-export declare function naturalTickCount(span: number, spacing: number, min: number): number;
-/**
- * Widens `[lo, hi]` outward to the nearest `count`-ish "nice" step -
- * equivalent to d3's own `scale.nice(count)`, except a value within
- * `epsilonFraction × step` of a step boundary is treated as already sitting
- * on it, rather than needing a full extra step to clear it.
- *
- * Exists because plain `Math.ceil`/`Math.floor` (what `nice()` uses
- * internally, both here and in d3) has zero tolerance: a value meant to be
- * exactly `100` that comes out `100.00000000000001` after summing several
- * independently-rounded parts (a common shape for "these categories add up
- * to a whole" data, e.g. percentages of a total) still fails `hi <= step*N`
- * and gets rounded up a full step further than the data actually warrants
- * (`100` → `110`, not just a hair past `100`). `epsilonFraction` defaults to
- * 1% of the step - small enough to only catch rounding/summation noise, not
- * data that's genuinely meaningfully past the boundary.
- */
-export declare function niceDomain(lo: number, hi: number, count?: number, epsilonFraction?: number): [number, number];

package/dist/layout/scales/niceDomain.js

@@ -1,59 +0,0 @@
-// d3-array-compatible "nice" tick step/generation, reimplemented locally to
-// avoid depending on internals svelteplot itself pulls in (not one of our
-// declared dependencies) - see https://d3js.org/d3-array/ticks.
-/** Step between "nice" (1/2/5×10ⁿ) tick values for an approximate `count` over `[start, stop]`. */
-export function tickStep(start, stop, count) {
-    const e10 = Math.sqrt(50);
-    const e5 = Math.sqrt(10);
-    const e2 = Math.sqrt(2);
-    const step0 = Math.abs(stop - start) / Math.max(0, count);
-    let step1 = 10 ** Math.floor(Math.log10(step0));
-    const error = step0 / step1;
-    if (error >= e10)
-        step1 *= 10;
-    else if (error >= e5)
-        step1 *= 5;
-    else if (error >= e2)
-        step1 *= 2;
-    return step1;
-}
-/** Multiples of `step` covering `[start, stop]`, inclusive of either endpoint when it lands exactly on one. */
-export function ticksInRange(start, stop, step) {
-    if (!(step > 0) || !Number.isFinite(step))
-        return [];
-    const lo = Math.ceil(start / step);
-    const hi = Math.floor(stop / step);
-    const out = [];
-    for (let i = lo; i <= hi; i++)
-        out.push(i * step);
-    return out;
-}
-/** Ticks-per-axis heuristic - used by `ScalesLayout` to pick a target count from an axis's actual pixel span. */
-export function naturalTickCount(span, spacing, min) {
-    return Math.max(min, Math.round(span / spacing));
-}
-/**
- * Widens `[lo, hi]` outward to the nearest `count`-ish "nice" step -
- * equivalent to d3's own `scale.nice(count)`, except a value within
- * `epsilonFraction × step` of a step boundary is treated as already sitting
- * on it, rather than needing a full extra step to clear it.
- *
- * Exists because plain `Math.ceil`/`Math.floor` (what `nice()` uses
- * internally, both here and in d3) has zero tolerance: a value meant to be
- * exactly `100` that comes out `100.00000000000001` after summing several
- * independently-rounded parts (a common shape for "these categories add up
- * to a whole" data, e.g. percentages of a total) still fails `hi <= step*N`
- * and gets rounded up a full step further than the data actually warrants
- * (`100` → `110`, not just a hair past `100`). `epsilonFraction` defaults to
- * 1% of the step - small enough to only catch rounding/summation noise, not
- * data that's genuinely meaningfully past the boundary.
- */
-export function niceDomain(lo, hi, count = 5, epsilonFraction = 0.01) {
-    if (!(hi > lo))
-        return [lo, hi];
-    const step = tickStep(lo, hi, count);
-    const eps = step * epsilonFraction;
-    const niceLo = Math.floor((lo + eps) / step) * step;
-    const niceHi = Math.ceil((hi - eps) / step) * step;
-    return [niceLo, niceHi];
-}

package/dist/plots/bar/defaults.d.ts

@@ -1,9 +0,0 @@
-import type { AxisPlotDefaults } from '../../types/phases';
-import type { BarPlotState, BarPlotCtx } from '../../types/plots/bar/state';
-/**
- * BarPlot on the shared pipeline: discrete bars with gap fills along one
- * category axis - `x`, or `y` for horizontal bars, as the "data" phase reads
- * it off the values - its own scales (padding, bar layout) and markers.
- * Its plot defaults to: hover along the category axis, timeline tweens matched per category and group.
- */
-export declare function buildBarDefaults<TData extends Record<string, unknown>>(): AxisPlotDefaults<BarPlotState<TData>, BarPlotCtx>;

package/dist/plots/geo/features.svelte.d.ts

@@ -1,5 +0,0 @@
-import type { GeoFeature, GeoJsonInput, Topology } from '../../types/plots/data/geo';
-/** A GeoPlot's `data` as a feature list: GeoJSON as is, a TopoJSON `Topology` converted under `object`. */
-export declare function createGeoFeatures<TProps extends Record<string, unknown>>(getData: () => GeoJsonInput<TProps> | Topology, getObject: () => string | undefined): {
-    readonly features: GeoFeature<TProps>[];
-};

package/dist/plots/geo/features.svelte.js

@@ -1,44 +0,0 @@
-import { isTopology, topologyToGeoJson } from '../utils/topojson';
-/** A GeoPlot's `data` as a feature list: GeoJSON as is, a TopoJSON `Topology` converted under `object`. */
-export function createGeoFeatures(getData, getObject) {
-    let topoFeatures = $state(null);
-    $effect(() => {
-        const data = getData();
-        const object = getObject();
-        if (!isTopology(data))
-            return;
-        if (!object) {
-            console.warn('GeoPlot: `data` is a TopoJSON Topology but no `object` key was given - nothing will render.');
-            topoFeatures = [];
-            return;
-        }
-        let cancelled = false;
-        topologyToGeoJson(data, object)
-            .then((resolved) => {
-            if (!cancelled)
-                topoFeatures = resolved;
-        })
-            .catch((err) => {
-            if (!cancelled) {
-                console.warn(err instanceof Error ? err.message : String(err));
-                topoFeatures = [];
-            }
-        });
-        return () => {
-            cancelled = true;
-        };
-    });
-    const features = $derived.by(() => {
-        const data = getData();
-        if (isTopology(data))
-            return topoFeatures ?? [];
-        if (Array.isArray(data))
-            return data;
-        return data.features;
-    });
-    return {
-        get features() {
-            return features;
-        }
-    };
-}

package/dist/plots/geo/phases/tooltip.js

@@ -1,5 +0,0 @@
-import { defaultFeatureId } from '../../utils/geoAccessors';
-/** GeoPlot's "tooltip" phase: a hovered feature reads as its id. */
-export function buildTooltip(state) {
-    return { ...state, tooltipFormat: (f) => defaultFeatureId(f) };
-}

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

@@ -1,72 +0,0 @@
-import type { GeoFeature } from '../../types/plots/data/geo';
-/**
- * Bounding-box center of a geometry's flattened coordinates - a cheap
- * approximation used for default label placement, not a true
- * geographic/area centroid (no polygon-hole or geodesic-area weighting).
- * For hover-matching specifically, see `geometryPartCentroids` instead -
- * this single combined point can land far from every actual part of a
- * multi-part geometry whose pieces are geographically spread out.
- */
-export declare function geometryCentroid(geometry: GeoJSON.Geometry): [number, number];
-/**
- * Splits a geometry into its disjoint parts: one `Polygon` per element of a
- * `MultiPolygon`'s `coordinates`, one `LineString` per element of a
- * `MultiLineString`'s, `GeometryCollection` recursed and flattened, and any
- * other geometry type returned unchanged as its own single-element array.
- * The shared building block behind `geometryPartCentroids` (one centroid per
- * part) and `filterGeometryParts` (keep/drop whole parts).
- */
-export declare function splitGeometryParts(geometry: GeoJSON.Geometry): GeoJSON.Geometry[];
-/**
- * Like `geometryCentroid`, but returns one point per disjoint part instead
- * of a single bounding-box center across all of them. A `MultiPolygon`
- * whose parts are geographically far apart - e.g. Argentina's "Tierra del
- * Fuego, Antártida e Islas del Atlántico Sur" province, whose `MultiPolygon`
- * spans the mainland island, the Antarctic sector, and the South Atlantic
- * islands in one feature - would otherwise get a single hover point
- * stranded somewhere between all of them, matching hovers over *none* of
- * the actually-rendered shapes. Multiple points attributed to the same
- * feature is fine for hover-matching (nearest point wins, whichever part
- * that is); it's only label placement (`geometryCentroid`) that needs a
- * single point.
- */
-export declare function geometryPartCentroids(geometry: GeoJSON.Geometry): [number, number][];
-/**
- * Keeps or drops each disjoint part of a geometry (see `splitGeometryParts`)
- * based on a per-part predicate, reassembling a geometry of the same type
- * from whatever survives - `null` if nothing does. Used to let a single
- * feature's geometry be split between the main map and an `inset` marker
- * (see `GeoDataProps.excludeParts`/`GeoInsetMarkerConfig.featurePartsFilter`)
- * without preprocessing the source data: e.g. a province whose `MultiPolygon`
- * spans both a mainland part and a far-flung part can have the main map
- * exclude the latter while an inset shows only it.
- */
-export declare function filterGeometryParts(geometry: GeoJSON.Geometry, keep: (part: {
-    centroid: [number, number];
-    geometry: GeoJSON.Geometry;
-}) => boolean): GeoJSON.Geometry | null;
-/** Default `featureId`: `feature.id`, else `properties.id`, else `properties.name`. */
-export declare function defaultFeatureId<TProps extends Record<string, unknown>>(f: GeoFeature<TProps>): string;
-/**
- * `[minLon, minLat, maxLon, maxLat]` across every coordinate of a geometry -
- * `null` for one with none (an empty `GeometryCollection`). Used by
- * `Plot.svelte`'s `dataLonLatBounds` to cap how far a tile layer's
- * letterboxed margin reaches (see `clampBoundsToDataPadding` in
- * `$lib/plots/utils/tiles`).
- */
-export declare function geometryLonLatBounds(geometry: GeoJSON.Geometry): [number, number, number, number] | null;
-/**
- * Densifies a great-circle arc between two lon/lat points into `steps + 1`
- * points via spherical linear interpolation (slerp) - used to draw a `link`
- * marker's geodesic curve through the `Geo` mark (see `Plot.svelte`).
- *
- * Not delegated to svelteplot's own `Link` mark: its 0.14.2 projection
- * integration (`Mark.svelte`'s paired-channel handling) reads a single
- * `row.x`/`row.y` pair regardless of channel suffix, so a mark bound to
- * `x1`/`y1`/`x2`/`y2` (never plain `x`/`y`) resolves every point as invalid
- * whenever the plot has an active `projection` scale - which GeoPlot always
- * does. `Geo` has no such limitation (geo marks are explicitly excluded from
- * that code path), so a manually-interpolated `LineString` feature sidesteps
- * the bug entirely while still producing the same geodesic visual.
- */
-export declare function greatCircleInterpolate(lon1: number, lat1: number, lon2: number, lat2: number, steps?: number): [number, number][];

package/dist/plots/utils/geoAccessors.js

@@ -1,220 +0,0 @@
-function flattenCoords(geom, out) {
-    switch (geom.type) {
-        case 'Point':
-            out.push(geom.coordinates);
-            break;
-        case 'MultiPoint':
-        case 'LineString':
-            for (const c of geom.coordinates)
-                out.push(c);
-            break;
-        case 'MultiLineString':
-        case 'Polygon':
-            for (const ring of geom.coordinates) {
-                for (const c of ring)
-                    out.push(c);
-            }
-            break;
-        case 'MultiPolygon':
-            for (const poly of geom.coordinates) {
-                for (const ring of poly) {
-                    for (const c of ring)
-                        out.push(c);
-                }
-            }
-            break;
-        case 'GeometryCollection':
-            for (const g of geom.geometries)
-                flattenCoords(g, out);
-            break;
-    }
-}
-function boundsCenter(coords) {
-    if (coords.length === 0)
-        return [0, 0];
-    let minX = Infinity;
-    let maxX = -Infinity;
-    let minY = Infinity;
-    let maxY = -Infinity;
-    for (const [x, y] of coords) {
-        if (x < minX)
-            minX = x;
-        if (x > maxX)
-            maxX = x;
-        if (y < minY)
-            minY = y;
-        if (y > maxY)
-            maxY = y;
-    }
-    return [(minX + maxX) / 2, (minY + maxY) / 2];
-}
-/**
- * Bounding-box center of a geometry's flattened coordinates - a cheap
- * approximation used for default label placement, not a true
- * geographic/area centroid (no polygon-hole or geodesic-area weighting).
- * For hover-matching specifically, see `geometryPartCentroids` instead -
- * this single combined point can land far from every actual part of a
- * multi-part geometry whose pieces are geographically spread out.
- */
-export function geometryCentroid(geometry) {
-    const coords = [];
-    flattenCoords(geometry, coords);
-    return boundsCenter(coords);
-}
-/**
- * Splits a geometry into its disjoint parts: one `Polygon` per element of a
- * `MultiPolygon`'s `coordinates`, one `LineString` per element of a
- * `MultiLineString`'s, `GeometryCollection` recursed and flattened, and any
- * other geometry type returned unchanged as its own single-element array.
- * The shared building block behind `geometryPartCentroids` (one centroid per
- * part) and `filterGeometryParts` (keep/drop whole parts).
- */
-export function splitGeometryParts(geometry) {
-    switch (geometry.type) {
-        case 'MultiPolygon':
-            return geometry.coordinates.map((polygon) => ({ type: 'Polygon', coordinates: polygon }));
-        case 'MultiLineString':
-            return geometry.coordinates.map((line) => ({ type: 'LineString', coordinates: line }));
-        case 'GeometryCollection':
-            return geometry.geometries.flatMap((g) => splitGeometryParts(g));
-        default:
-            return [geometry];
-    }
-}
-/**
- * Like `geometryCentroid`, but returns one point per disjoint part instead
- * of a single bounding-box center across all of them. A `MultiPolygon`
- * whose parts are geographically far apart - e.g. Argentina's "Tierra del
- * Fuego, Antártida e Islas del Atlántico Sur" province, whose `MultiPolygon`
- * spans the mainland island, the Antarctic sector, and the South Atlantic
- * islands in one feature - would otherwise get a single hover point
- * stranded somewhere between all of them, matching hovers over *none* of
- * the actually-rendered shapes. Multiple points attributed to the same
- * feature is fine for hover-matching (nearest point wins, whichever part
- * that is); it's only label placement (`geometryCentroid`) that needs a
- * single point.
- */
-export function geometryPartCentroids(geometry) {
-    return splitGeometryParts(geometry).map((part) => geometryCentroid(part));
-}
-/**
- * Keeps or drops each disjoint part of a geometry (see `splitGeometryParts`)
- * based on a per-part predicate, reassembling a geometry of the same type
- * from whatever survives - `null` if nothing does. Used to let a single
- * feature's geometry be split between the main map and an `inset` marker
- * (see `GeoDataProps.excludeParts`/`GeoInsetMarkerConfig.featurePartsFilter`)
- * without preprocessing the source data: e.g. a province whose `MultiPolygon`
- * spans both a mainland part and a far-flung part can have the main map
- * exclude the latter while an inset shows only it.
- */
-export function filterGeometryParts(geometry, keep) {
-    const parts = splitGeometryParts(geometry);
-    const keptParts = parts.filter((part) => keep({ centroid: geometryCentroid(part), geometry: part }));
-    if (keptParts.length === parts.length)
-        return geometry;
-    if (keptParts.length === 0)
-        return null;
-    if (parts.length === 1)
-        return keptParts[0];
-    switch (geometry.type) {
-        case 'MultiPolygon':
-            return {
-                type: 'MultiPolygon',
-                coordinates: keptParts.map((part) => part.coordinates)
-            };
-        case 'MultiLineString':
-            return {
-                type: 'MultiLineString',
-                coordinates: keptParts.map((part) => part.coordinates)
-            };
-        case 'GeometryCollection':
-            return { type: 'GeometryCollection', geometries: keptParts };
-        default:
-            return geometry;
-    }
-}
-/** Default `featureId`: `feature.id`, else `properties.id`, else `properties.name`. */
-export function defaultFeatureId(f) {
-    const props = f.properties;
-    return String(f.id ?? props?.id ?? props?.name ?? '');
-}
-/**
- * `[minLon, minLat, maxLon, maxLat]` across every coordinate of a geometry -
- * `null` for one with none (an empty `GeometryCollection`). Used by
- * `Plot.svelte`'s `dataLonLatBounds` to cap how far a tile layer's
- * letterboxed margin reaches (see `clampBoundsToDataPadding` in
- * `$lib/plots/utils/tiles`).
- */
-export function geometryLonLatBounds(geometry) {
-    const coords = [];
-    flattenCoords(geometry, coords);
-    if (coords.length === 0)
-        return null;
-    let minLon = Infinity;
-    let maxLon = -Infinity;
-    let minLat = Infinity;
-    let maxLat = -Infinity;
-    for (const [lon, lat] of coords) {
-        if (lon < minLon)
-            minLon = lon;
-        if (lon > maxLon)
-            maxLon = lon;
-        if (lat < minLat)
-            minLat = lat;
-        if (lat > maxLat)
-            maxLat = lat;
-    }
-    return [minLon, minLat, maxLon, maxLat];
-}
-function toRad(deg) {
-    return (deg * Math.PI) / 180;
-}
-function toDeg(rad) {
-    return (rad * 180) / Math.PI;
-}
-/**
- * Densifies a great-circle arc between two lon/lat points into `steps + 1`
- * points via spherical linear interpolation (slerp) - used to draw a `link`
- * marker's geodesic curve through the `Geo` mark (see `Plot.svelte`).
- *
- * Not delegated to svelteplot's own `Link` mark: its 0.14.2 projection
- * integration (`Mark.svelte`'s paired-channel handling) reads a single
- * `row.x`/`row.y` pair regardless of channel suffix, so a mark bound to
- * `x1`/`y1`/`x2`/`y2` (never plain `x`/`y`) resolves every point as invalid
- * whenever the plot has an active `projection` scale - which GeoPlot always
- * does. `Geo` has no such limitation (geo marks are explicitly excluded from
- * that code path), so a manually-interpolated `LineString` feature sidesteps
- * the bug entirely while still producing the same geodesic visual.
- */
-export function greatCircleInterpolate(lon1, lat1, lon2, lat2, steps = 64) {
-    const phi1 = toRad(lat1);
-    const lambda1 = toRad(lon1);
-    const phi2 = toRad(lat2);
-    const lambda2 = toRad(lon2);
-    const sinPhi1 = Math.sin(phi1);
-    const cosPhi1 = Math.cos(phi1);
-    const sinPhi2 = Math.sin(phi2);
-    const cosPhi2 = Math.cos(phi2);
-    const d = 2 *
-        Math.asin(Math.sqrt(Math.sin((phi2 - phi1) / 2) ** 2 +
-            cosPhi1 * cosPhi2 * Math.sin((lambda2 - lambda1) / 2) ** 2));
-    if (!Number.isFinite(d) || d === 0) {
-        return [
-            [lon1, lat1],
-            [lon2, lat2]
-        ];
-    }
-    const points = [];
-    for (let i = 0; i <= steps; i++) {
-        const f = i / steps;
-        const a = Math.sin((1 - f) * d) / Math.sin(d);
-        const b = Math.sin(f * d) / Math.sin(d);
-        const x = a * cosPhi1 * Math.cos(lambda1) + b * cosPhi2 * Math.cos(lambda2);
-        const y = a * cosPhi1 * Math.sin(lambda1) + b * cosPhi2 * Math.sin(lambda2);
-        const z = a * sinPhi1 + b * sinPhi2;
-        const phi = Math.atan2(z, Math.sqrt(x * x + y * y));
-        const lambda = Math.atan2(y, x);
-        points.push([toDeg(lambda), toDeg(phi)]);
-    }
-    return points;
-}

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

@@ -1,29 +0,0 @@
-import type { ChannelScalesConfig } from '../../types/layout/scales';
-import type { Segment } from '../../types/plots/segments/config';
-import type { SegmentsConfig } from '../../types/plots/props';
-/**
- * Feature-specific segments listed after 'default' so they override it on
- * merge (see `resolveFeatureStyle`). When the feature has a resolved
- * `grouping` bucket, that bucket's own entries are listed in between -
- * `default` < grouping bucket < feature-specific, most specific last.
- */
-export declare function resolveSegmentsForFeature<TStyle>(segments: SegmentsConfig<TStyle>, featureId: string, groupingValue?: string): Segment<TStyle>[];
-/**
- * A geo feature is atomic - `Segment.areas` (x/y range restriction) doesn't
- * apply, so every entry under a key is treated as a flat style patch applied
- * in order: `'default'` entries apply first, then the grouping bucket's (if
- * any), then feature-specific entries. This intentionally does NOT reuse
- * `segments.ts`'s `validateSegments` - its "only the first catch-all wins"
- * warning assumes area-based semantics that don't hold here, since every geo
- * segment entry merges rather than being dropped.
- */
-export declare function resolveFeatureStyle<TStyle extends object>(segments: SegmentsConfig<TStyle>, featureId: string, groupingValue?: string): TStyle;
-/**
- * A feature's own effective `scales` override, if any of its matching
- * segments (`default`, its grouping bucket, or itself) set one - the last
- * (most specific) entry that defines `scales` wins outright, unlike
- * `resolveFeatureStyle`'s field-by-field merge, since a ramp config isn't
- * sensibly mergeable key-by-key (a `domain` from one entry and a `scheme`
- * from another wouldn't be a coherent scale).
- */
-export declare function resolveFeatureScales<TStyle>(segments: SegmentsConfig<TStyle>, featureId: string, groupingValue?: string): ChannelScalesConfig | undefined;

package/dist/plots/utils/geoSegments.js

@@ -1,37 +0,0 @@
-const DEFAULT_KEY = 'default';
-/**
- * Feature-specific segments listed after 'default' so they override it on
- * merge (see `resolveFeatureStyle`). When the feature has a resolved
- * `grouping` bucket, that bucket's own entries are listed in between -
- * `default` < grouping bucket < feature-specific, most specific last.
- */
-export function resolveSegmentsForFeature(segments, featureId, groupingValue) {
-    return [
-        ...(segments[DEFAULT_KEY] ?? []),
-        ...(groupingValue ? (segments[groupingValue] ?? []) : []),
-        ...(segments[featureId] ?? [])
-    ];
-}
-/**
- * A geo feature is atomic - `Segment.areas` (x/y range restriction) doesn't
- * apply, so every entry under a key is treated as a flat style patch applied
- * in order: `'default'` entries apply first, then the grouping bucket's (if
- * any), then feature-specific entries. This intentionally does NOT reuse
- * `segments.ts`'s `validateSegments` - its "only the first catch-all wins"
- * warning assumes area-based semantics that don't hold here, since every geo
- * segment entry merges rather than being dropped.
- */
-export function resolveFeatureStyle(segments, featureId, groupingValue) {
-    return resolveSegmentsForFeature(segments, featureId, groupingValue).reduce((acc, seg) => ({ ...acc, ...(seg.styles ?? {}) }), {});
-}
-/**
- * A feature's own effective `scales` override, if any of its matching
- * segments (`default`, its grouping bucket, or itself) set one - the last
- * (most specific) entry that defines `scales` wins outright, unlike
- * `resolveFeatureStyle`'s field-by-field merge, since a ramp config isn't
- * sensibly mergeable key-by-key (a `domain` from one entry and a `scheme`
- * from another wouldn't be a coherent scale).
- */
-export function resolveFeatureScales(segments, featureId, groupingValue) {
-    return resolveSegmentsForFeature(segments, featureId, groupingValue).reduce((acc, seg) => seg.scales ?? acc, undefined);
-}