@fundar/data-chart-telling 1.1.0 → 1.2.0

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);
-}

package/dist/types/layout/styles.d.ts

@@ -1,122 +0,0 @@
-import type { ValueAnchor } from '../plots/constants';
-import type { FontStyle, StrokeStyle, AreaStyle } from '../plots/styling';
-import type { GeoFeature } from '../plots/data/geo';
-import type { GapsConfig } from '../plots/gaps';
-/**
- * Controls if and how value labels are rendered on a plot, drawn as a `text`
- * marker over the rows the plot itself draws (after its own `transforms`):
- * one at the end of each series on a line or area plot, one per bar on a bar,
- * pyramid or histogram plot, one per point on a scatter plot and one per cell
- * on a heatmap. The high-level `anchor` sets sensible defaults for placement;
- * `fontStyle` (`dx`, `dy`, `textAnchor`, `lineAnchor`, `lineHeight`, `rotate`,
- * `class`, `textClass`, `fill`, …) overrides those defaults field-by-field when
- * provided - mirrors {@link DeltaConfig}'s `fontStyle`/`strokeStyle` split, so
- * label text and connector-line styling never mix into one flat bag of props.
- */
-export type ValuesStyle = {
-    /** Whether the labels are drawn. Off by default, except on a heatmap. */
-    show?: boolean;
-    /** Where each label sits on its mark - see {@link ValueAnchor}. */
-    anchor?: ValueAnchor;
-    /** A label's text, from its row's own value (a histogram bin's count) and its series. */
-    format?: (value: number, seriesName: string) => string;
-    /** Hovering a label dims every other series, like toggling them off in the legend. */
-    hoverIsolate?: boolean;
-    fontStyle?: FontStyle;
-    /** The connectors a line or area plot routes back from labels that had to move apart. */
-    strokeStyle?: StrokeStyle;
-};
-/**
- * Decorative border around the plot's own content box - svelteplot's
- * `Frame` mark, purely cosmetic (drawn from the box geometry, never from
- * data). `true` enables it with svelteplot's own defaults; an object
- * enables it and overrides its look field-by-field. Insets pull the frame
- * in from the content box's own edges, in pixels.
- */
-export type FrameStyle = AreaStyle & {
-    inset?: number;
-    insetTop?: number;
-    insetRight?: number;
-    insetBottom?: number;
-    insetLeft?: number;
-};
-/** Author-facing `styles.frame` prop - see {@link FrameStyle}. */
-export type FrameProp = boolean | FrameStyle;
-/**
- * The fields every plot kind's own `styles` shape shares - the common parent
- * of {@link AxisBasedStylesConfig} and {@link GeoStylesConfig}.
- */
-export type BasePlotStylesConfig = {
-    /** Decorative border around the plot's content box - see {@link FrameStyle}. Available on every plot kind. */
-    frame?: FrameProp;
-};
-/**
- * Top-level rendering style overrides shared by the non-geo plot kinds.
- * Passed as the `styles` prop. Each plot reads only the fields it cares
- * about.
- */
-export type AxisBasedStylesConfig = BasePlotStylesConfig & {
-    values?: ValuesStyle;
-};
-/**
- * `AxisBasedStylesConfig` extended with `gaps` - the interpolated
- * missing-data bridge fill available to plot kinds with an inherent
- * category/sequence ordering (`LinePlot`, `BarPlot`, `PyramidPlot`).
- * Resolved per series like `segments`, at zone granularity - see
- * {@link GapsConfig}.
- */
-export type GapsAwarePlotStylesConfig<TSegmentStyle extends object> = AxisBasedStylesConfig & {
-    gaps?: GapsConfig<TSegmentStyle>;
-};
-export type GeoTileLayerConfig = {
-    /** XYZ tile URL template, e.g. `'https://tile.openstreetmap.org/{z}/{x}/{y}.png'`. */
-    url: string;
-    attribution?: string;
-    opacity?: number;
-    minZoom?: number;
-    maxZoom?: number;
-    /** Tile edge length in pixels. Defaults to `256`. */
-    tileSize?: number;
-};
-/**
- * `styles` prop for GeoPlot - the geo analog of `AxisBasedStylesConfig`,
- * sharing only {@link BasePlotStylesConfig}'s common ground with it. Unlike
- * the other plot kinds, GeoPlot's styling needs (base map, choropleth ramp,
- * tile background, click handling) are unlike anything x/y plots need, so
- * this is its own type rather than a reuse of `AxisBasedStylesConfig`.
- */
-export type GeoStylesConfig<TProps extends Record<string, unknown> = Record<string, unknown>> = BasePlotStylesConfig & {
-    /** Base map fill, used when a feature isn't styled by `segments` or the choropleth ramp. */
-    fill?: string;
-    fillOpacity?: number;
-    stroke?: string;
-    strokeWidth?: number;
-    /** Raster XYZ tile basemap under the vector geometry. Mercator-family projections only. */
-    tileLayer?: GeoTileLayerConfig;
-    /** Fired when a base-map feature is clicked. */
-    onFeatureClick?: (feature: GeoFeature<TProps>, event: Event) => void;
-};
-/**
- * `GeoTileLayerConfig`, plus `features` - never author-facing (the public
- * `styles.tileLayer` shape, {@link GeoTileLayerConfig}, doesn't declare it).
- * `GeoPlot` tacks it onto its own internal copy of `styles` so `StylesLayout`
- * can compute the tile layer's auto-fit bounds without needing raw geometry
- * threaded through as a separate prop.
- */
-type GeoTileLayerConfigWithFeatures = GeoTileLayerConfig & {
-    features?: {
-        geometry: GeoJSON.Geometry;
-    }[];
-};
-/**
- * The minimal slice of a plot kind's own `styles` prop `StylesLayout` reads -
- * every concrete `styles` type ({@link AxisBasedStylesConfig},
- * {@link GeoStylesConfig}) structurally satisfies this whether or not it
- * declares `tileLayer` at all (a missing optional field type-checks fine).
- */
-export type StylesLayoutConfig = {
-    tileLayer?: GeoTileLayerConfigWithFeatures;
-    frame?: FrameProp;
-    [key: string]: unknown;
-};
-export {};

package/dist/types/markers/axis/curveName.d.ts

@@ -1,2 +0,0 @@
-/** Curve interpolation for an area, difference or trail marker - svelteplot's own `CurveName`. */
-export type MarkerCurveName = 'basis' | 'basis-closed' | 'basis-open' | 'bundle' | 'bump-x' | 'bump-y' | 'cardinal' | 'cardinal-closed' | 'cardinal-open' | 'catmull-rom' | 'catmull-rom-closed' | 'catmull-rom-open' | 'linear' | 'linear-closed' | 'monotone-x' | 'monotone-y' | 'natural' | 'step' | 'step-after' | 'step-before';

package/dist/types/plots/line/props.d.ts

@@ -1,10 +0,0 @@
-import type { BasePlotProps, PlotCoreProps } from '../props';
-import type { AxisBasedScalesConfig } from '../../layout/scales';
-import type { AxisBasedMarkersConfig } from '../../markers/common';
-import type { SeriesProps, DataProps } from '../data/common';
-import type { GapsAwarePlotStylesConfig } from '../../layout/styles';
-import type { LineSegmentStyle } from '../segments/common';
-/** `LinePlot`'s public props. */
-export type LinePlotProps<TData extends Record<string, unknown>> = BasePlotProps<SeriesProps<TData> | DataProps<TData>, TData, GapsAwarePlotStylesConfig<LineSegmentStyle>, LineSegmentStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
-/** What `LinePlot`'s core draws from. */
-export type LinePlotCoreProps<TData extends Record<string, unknown>> = PlotCoreProps<SeriesProps<TData> | DataProps<TData>, TData, GapsAwarePlotStylesConfig<LineSegmentStyle>, LineSegmentStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;

package/dist/utils/color/contrast.d.ts

@@ -1,9 +0,0 @@
-/** WCAG contrast ratio between two colors, from 1 (no contrast) to 21 (black on white). */
-export declare function contrastRatio(colorA: string, colorB: string): number;
-/**
- * The `candidates` entry with the highest WCAG contrast ratio against
- * `background`. Defaults to plain white/black; pass a grayscale or other
- * palette to widen the choice. Falls back to the first candidate when
- * `background` can't be parsed.
- */
-export declare function contrastTextColor(background: string, candidates?: string[]): string;

package/dist/utils/color/contrast.js

@@ -1,40 +0,0 @@
-import { resolveCssColor, parseRgb } from './cssColor';
-function relativeLuminance([r, g, b]) {
-    const [rs, gs, bs] = [r, g, b].map((c) => {
-        const s = c / 255;
-        return s <= 0.03928 ? s / 12.92 : Math.pow((s + 0.055) / 1.055, 2.4);
-    });
-    return 0.2126 * rs + 0.7152 * gs + 0.0722 * bs;
-}
-/** WCAG contrast ratio between two colors, from 1 (no contrast) to 21 (black on white). */
-export function contrastRatio(colorA, colorB) {
-    const a = parseRgb(resolveCssColor(colorA));
-    const b = parseRgb(resolveCssColor(colorB));
-    if (!a || !b)
-        return 1;
-    const lA = relativeLuminance(a);
-    const lB = relativeLuminance(b);
-    const lighter = Math.max(lA, lB);
-    const darker = Math.min(lA, lB);
-    return (lighter + 0.05) / (darker + 0.05);
-}
-/**
- * The `candidates` entry with the highest WCAG contrast ratio against
- * `background`. Defaults to plain white/black; pass a grayscale or other
- * palette to widen the choice. Falls back to the first candidate when
- * `background` can't be parsed.
- */
-export function contrastTextColor(background, candidates = ['#ffffff', '#000000']) {
-    if (candidates.length === 0)
-        return '#000000';
-    let best = candidates[0];
-    let bestRatio = -Infinity;
-    for (const candidate of candidates) {
-        const ratio = contrastRatio(background, candidate);
-        if (ratio > bestRatio) {
-            bestRatio = ratio;
-            best = candidate;
-        }
-    }
-    return best;
-}

package/dist/utils/color/cssColor.d.ts

@@ -1,4 +0,0 @@
-/** Resolves a `var(--x)` reference to its computed value; any other CSS color string passes through unchanged. */
-export declare function resolveCssColor(color: string): string;
-/** Parses any CSS color syntax (hex, rgb(), oklch(), named colors, hsl(), ...) into an `[r, g, b]` (0-255) triple, or `null` if it can't be resolved. */
-export declare function parseRgb(color: string): [number, number, number] | null;