@fundar/data-chart-telling 0.0.64 → 1.1.0

package/dist/layout/plot/BasePlotLayout.svelte

@@ -1,332 +0,0 @@
-<script
-	lang="ts"
-	generics="TData extends Record<string, unknown>, TSeries extends Record<string, unknown> = TData"
->
-	import type { ComponentProps, Snippet } from 'svelte';
-	import { Plot, Pointer, setPlotDefaults } from 'svelteplot';
-	import { getConfiguration } from '../../configuration/config.svelte';
-	import { AUTO_MARGIN_ESTIMATE, numericMargin } from './margins';
-	import { buildScale } from '../scales/buildScale';
-	import ScalesLayout from '../scales/ScalesLayout.svelte';
-	import GeometryLayout from '../geometry/GeometryLayout.svelte';
-	import CoordinatesLayout from '../coordinates/CoordinatesLayout.svelte';
-	import StylesLayout from '../styles/StylesLayout.svelte';
-	import { getHover, createHover } from '../tooltip/hover.svelte';
-	import { createHoverController } from '../tooltip/controller.svelte';
-	import TooltipLayout from '../tooltip/TooltipLayout.svelte';
-	import type { AxisValue, AxisBasedScalesConfig } from '../../types/layout/scales';
-	import type { CoordinatesConfig } from '../../types/layout/coordinates';
-	import type { StylesLayoutConfig } from '../../types/layout/styles';
-	import type { ScopedMarkerGroup } from '../../types/layout/geometry';
-	import type { HoverPoint } from '../../types/layout/tooltip';
-	import type { MarginConfig, HoverConfig } from '../../types/plots/props';
-	import type { MarkerConfig } from '../../types/markers/all';
-	import type { Series } from '../../types/plots/data/common';
-	import type { GeoFeature } from '../../types/plots/data/geo';
-
-	type SveltePlotProps = ComponentProps<typeof Plot>;
-
-	/**
-	 * Shared chrome around every plot kind's svelteplot markup: the
-	 * pointer-event wrapper, the hover/tooltip state machine, and the floating
-	 * tooltip. Composes the Coordinates and Styles layers around every plot
-	 * kind's own content, plus `GeometryLayout` (which renders nothing extra
-	 * when `markers` is empty/unset). `ScalesLayout` composes in
-	 * independently, only when `scales` is passed. Every plot kind supplies
-	 * its own `<Plot x y projection>` scale config, either directly via
-	 * `x`/`y` or by leaving them unset so this component derives them from
-	 * `scales`.
-	 */
-	let {
-		width,
-		height,
-		data,
-		getX,
-		getY,
-		hover,
-		x = undefined,
-		y = undefined,
-		scales = undefined,
-		coordinates = undefined,
-		margins,
-		marginEstimate = AUTO_MARGIN_ESTIMATE,
-		marginRemountKey = undefined,
-		xTickRotate = undefined,
-		styles = undefined,
-		markers = undefined,
-		seriesData = undefined,
-		scopedGroups = undefined,
-		geoAllFeatures = undefined,
-		containerEl = $bindable(undefined),
-		children
-	}: {
-		width: number;
-		height: number;
-		/** Flat rows fed to svelteplot's `<Pointer>` for nearest-point matching, and to `CoordinatesLayout` for a `domain: 'data'` projection auto-fit. */
-		data: TData[];
-		getX: (d: TData) => AxisValue;
-		getY: (d: TData) => AxisValue;
-		/** Every hover/tooltip prop this component's own hover machinery reads — see {@link HoverConfig}. */
-		hover: HoverConfig<TData>;
-		/** Explicit `<Plot x>` override — bypasses `scales`-derived resolution (e.g. GeoPlot's fixed lon/lat domain). */
-		x?: SveltePlotProps['x'];
-		/** Explicit `<Plot y>` override — see `x`. */
-		y?: SveltePlotProps['y'];
-		/** Scale config `x`/`y` are derived from when not given directly. */
-		scales?: AxisBasedScalesConfig<TData>;
-		/** This plot kind's coordinate system config — `GeoPlot` only (a projection + pan/zoom). */
-		coordinates?: CoordinatesConfig;
-		/** Partial margin override — merged on top of the theme. */
-		margins?: MarginConfig;
-		/** Numeric fallback for a margin side that resolved to `'auto'` — see `numericMargin`'s doc comment. */
-		marginEstimate?: Record<'top' | 'right' | 'bottom' | 'left', number>;
-		/**
-		 * Forces svelteplot's own `<Plot>` to fully unmount/remount (via
-		 * `{#key}`) whenever this changes, instead of reacting to a `margins`
-		 * prop change on an already-mounted instance. Only needed by a caller
-		 * (line's own `Plot.svelte`) whose `margins` grows *after* mount, from
-		 * measuring rendered content (see `createLabelMarginTracker`) — handing
-		 * svelteplot's `<Plot>` a live post-mount margin change (rather than the
-		 * same final value from its very first mount) was observed to send its
-		 * own internal auto-margin sizing into a permanent one-pixel
-		 * bottom-margin oscillation for line's end-point value labels
-		 * specifically, which in turn kept re-triggering the overflow watcher
-		 * that grew the margin in the first place — an infinite effect loop
-		 * that tripped Svelte's `effect_update_depth_exceeded` guard. A static
-		 * `margins` prop (the common case — every other plot kind) never needs
-		 * this; leave it unset there.
-		 */
-		marginRemountKey?: string | number;
-		/** Boosts the bottom margin for a rotated x tick label — axis-having plot kinds only. */
-		xTickRotate?: number;
-		/** This plot kind's own `styles` prop, forwarded to the Styles layer. */
-		styles?: StylesLayoutConfig;
-		/**
-		 * This plot kind's own markers array. Accepts a plain array, or a
-		 * builder function for a plot kind whose own marker construction needs
-		 * `setHoverMatch`/`clearHoverMatch`, only available once this
-		 * component's own hover controller is set up.
-		 */
-		markers?:
-			| MarkerConfig[]
-			| ((hover: {
-					setHoverMatch: (rows: TData[]) => void;
-					clearHoverMatch: () => void;
-			  }) => MarkerConfig[]);
-		/** All resolved series, forwarded to `GeometryLayout` — axis-based kinds only. Independently generic over `TSeries` (defaults to `TData`). */
-		seriesData?: Series<TSeries>[];
-		/** Per-series `GeometryLayout` groups — axis-based kinds only, same `TSeries` as `seriesData`. */
-		scopedGroups?: ScopedMarkerGroup<TSeries>[];
-		/** `GeoPlot`'s own untouched, tagged features, forwarded to `GeometryLayout` — `inset` marker only. */
-		geoAllFeatures?: (GeoFeature<Record<string, unknown>> & { __id: string })[];
-		/** The wrapper div's own element — bind for a nested layout that needs it for its own gesture handling (e.g. `CoordinatesLayout`'s zoom/rotate). */
-		containerEl?: HTMLDivElement;
-		/**
-		 * `matchedPoints` carries the source `row` alongside the display fields,
-		 * so a template can resolve it straight off `row` instead of assuming
-		 * which visual axis it landed on. `activePoint` is the one matched point
-		 * under the cursor. `numericMargins` lets a nested layout align itself
-		 * with the plot's own content box. `setHoverMatch`/`clearHoverMatch` let
-		 * a plot kind drive the match itself instead of svelteplot's
-		 * distance-based `<Pointer>` — see `hover.pointMatching`. When `markers`
-		 * is given, this is `GeometryLayout`'s own `children` instead of raw
-		 * plot content. Optional — a plot kind whose every mark is a `markers`
-		 * entry has nothing left to render here.
-		 */
-		children?: Snippet<
-			[
-				{
-					matchedPoints: HoverPoint<TData>[];
-					activePoint: HoverPoint<TData> | null;
-					impliesCrosshairX: boolean;
-					impliesCrosshairY: boolean;
-					numericMargins: { top: number; right: number; bottom: number; left: number };
-					setHoverMatch: (rows: TData[]) => void;
-					clearHoverMatch: () => void;
-				}
-			]
-		>;
-	} = $props();
-
-	const cfg = $derived(getConfiguration());
-	setPlotDefaults({
-		numberFormat: { useGrouping: 'min2', compactDisplay: cfg.axis.compactDisplay }
-	});
-
-	/**
-	 * Margins passed straight to `<Plot margin={…}>`. Each side defaults to
-	 * `'auto'` (from the theme), which lets svelteplot size it to whatever it
-	 * actually renders there — tick labels, an axis title, rotated ticks —
-	 * rather than a fixed guess that either clips content or wastes space.
-	 * `margins`/`cfg.margins` can still pin a side to an exact number.
-	 */
-	const computedMargins = $derived.by(() => {
-		const base = { ...cfg.margins, ...margins };
-		// Auto margins already measure the real (rotated) label bounding box, so
-		// this manual boost is only needed when the caller pinned bottom to a
-		// fixed number, which bypasses that measurement.
-		if (!xTickRotate || typeof base.bottom !== 'number') return base;
-		const rad = (Math.abs(xTickRotate) * Math.PI) / 180;
-		return {
-			...base,
-			bottom: base.bottom + Math.ceil(Math.sin(rad) * 20)
-		};
-	});
-
-	const numericMargins = $derived({
-		top: numericMargin('top', computedMargins.top, marginEstimate),
-		right: numericMargin('right', computedMargins.right, marginEstimate),
-		bottom: numericMargin('bottom', computedMargins.bottom, marginEstimate),
-		left: numericMargin('left', computedMargins.left, marginEstimate)
-	});
-
-	// Cast to svelteplot's own (narrower, axis-specific) scale option type:
-	// buildScale has already stripped the fields that don't exist there
-	// (grid, the vertical label config, BarPlot's series-layout knobs).
-	const resolvedX = $derived(
-		x !== undefined ? x : (buildScale(scales?.x, data, getX) as SveltePlotProps['x'])
-	);
-	const resolvedY = $derived(
-		y !== undefined ? y : (buildScale(scales?.y, data, getY) as SveltePlotProps['y'])
-	);
-
-	/** Only ever meaningful for `GeoPlot`. `none` while any interactive gesture (`zoom`/`pan`/`rotate`) is on. */
-	const touchAction = $derived(
-		(coordinates?.zoom !== false && coordinates?.zoom != null) ||
-			coordinates?.pan ||
-			coordinates?.rotate
-			? 'none'
-			: undefined
-	);
-
-	// ── Hover / tooltip ───────────────────────────────────────────────────────
-	const sharedHover = getHover();
-	const localHover = createHover();
-	const hoverStore = $derived(sharedHover ?? localHover);
-
-	/** Declared intent, defaulted — see {@link HoverConfig.pointMatching}. */
-	const pointMatchingStrategy = $derived(hover.pointMatching ?? 'nearest');
-
-	/**
-	 * Which axes svelteplot's `<Pointer>` should search along, derived from
-	 * the active strategy. `undefined` for an axis collapses every point to
-	 * the same coordinate on that axis, excluding it from the match entirely.
-	 */
-	const pointerMatchX = $derived(hoverStore.strategy === 'y' ? undefined : getX);
-	const pointerMatchY = $derived(hoverStore.strategy === 'x' ? undefined : getY);
-
-	$effect(() => {
-		if (sharedHover) return;
-		localHover.strategy = hover.strategy ?? 'x';
-		localHover.sync = hover.sync ?? false;
-	});
-
-	const ctrl = createHoverController<TData>({
-		hover: () => hoverStore,
-		facetId: () => hover.tooltip?.facetId ?? '',
-		points: () => hover.points,
-		getX: () => getX,
-		getY: () => getY,
-		label: () => hover.label,
-		seriesFilter: () => hover.tooltip?.series,
-		width: () => width,
-		height: () => height,
-		crosshair: () => hover.crosshair
-	});
-
-	function onMove(e: PointerEvent) {
-		if (hover.exclude?.(e)) {
-			ctrl.onLeave();
-			return;
-		}
-		ctrl.onMove(e);
-	}
-
-	const resolvedMarkers = $derived(
-		typeof markers === 'function'
-			? markers({ setHoverMatch: ctrl.onPointer, clearHoverMatch: ctrl.onLeave })
-			: markers
-	);
-</script>
-
-<!-- svelte-ignore a11y_no_static_element_interactions -->
-<div
-	class="dct-plot"
-	bind:this={containerEl}
-	style:color={cfg.axis.color}
-	style:touch-action={touchAction}
-	onpointermove={hover.active ? onMove : undefined}
-	onpointerleave={hover.active ? ctrl.onLeave : undefined}
->
-	<CoordinatesLayout
-		{width}
-		{height}
-		margin={computedMargins}
-		x={resolvedX}
-		y={resolvedY}
-		{coordinates}
-		locale={cfg.axis.locale}
-		{data}
-		{containerEl}
-		remountKey={marginRemountKey}
-	>
-		<StylesLayout {styles} {width} {height} {numericMargins} />
-		{#if scales !== undefined}
-			<ScalesLayout {data} {getX} {getY} {width} {height} {numericMargins} {scales} />
-		{/if}
-		<GeometryLayout
-			markers={resolvedMarkers}
-			seriesData={seriesData ?? []}
-			scopedGroups={scopedGroups ?? []}
-			{ctrl}
-			{width}
-			{height}
-			{numericMargins}
-			{data}
-			{geoAllFeatures}
-			tooltipAnchorX={hover.tooltip?.anchorX}
-			tooltipAnchorY={hover.tooltip?.anchorY}
-		>
-			{@render children?.({
-				matchedPoints: ctrl.points,
-				activePoint: ctrl.activePoint,
-				impliesCrosshairX: ctrl.impliesCrosshairX,
-				impliesCrosshairY: ctrl.impliesCrosshairY,
-				numericMargins,
-				setHoverMatch: ctrl.onPointer,
-				clearHoverMatch: ctrl.onLeave
-			})}
-		</GeometryLayout>
-
-		{#if hover.active && pointMatchingStrategy === 'nearest'}
-			<Pointer
-				{data}
-				x={pointerMatchX}
-				y={pointerMatchY}
-				maxDistance={400}
-				onupdate={ctrl.onPointer}
-			/>
-		{/if}
-	</CoordinatesLayout>
-
-	{#if hover.tooltip}
-		<TooltipLayout
-			visible={ctrl.showTooltip && ctrl.tooltipPosition != null}
-			x={ctrl.tooltipPosition?.x ?? 0}
-			y={ctrl.tooltipPosition?.y ?? 0}
-			bounds={{ width, height }}
-			rows={ctrl.matchedRows.map((p) => p.row)}
-			format={hover.tooltip.format}
-			content={hover.tooltip.content}
-			anchorX={hover.tooltip.anchorX}
-			anchorY={hover.tooltip.anchorY}
-		/>
-	{/if}
-</div>
-
-<style>
-	.dct-plot {
-		position: relative;
-		line-height: 0;
-	}
-</style>

package/dist/layout/plot/BasePlotLayout.svelte.d.ts

@@ -1,122 +0,0 @@
-import type { Snippet } from 'svelte';
-import type { AxisValue, AxisBasedScalesConfig } from '../../types/layout/scales';
-import type { CoordinatesConfig } from '../../types/layout/coordinates';
-import type { StylesLayoutConfig } from '../../types/layout/styles';
-import type { ScopedMarkerGroup } from '../../types/layout/geometry';
-import type { HoverPoint } from '../../types/layout/tooltip';
-import type { MarginConfig, HoverConfig } from '../../types/plots/props';
-import type { MarkerConfig } from '../../types/markers/all';
-import type { Series } from '../../types/plots/data/common';
-import type { GeoFeature } from '../../types/plots/data/geo';
-declare function $$render<TData extends Record<string, unknown>, TSeries extends Record<string, unknown> = TData>(): {
-    props: {
-        width: number;
-        height: number;
-        /** Flat rows fed to svelteplot's `<Pointer>` for nearest-point matching, and to `CoordinatesLayout` for a `domain: 'data'` projection auto-fit. */
-        data: TData[];
-        getX: (d: TData) => AxisValue;
-        getY: (d: TData) => AxisValue;
-        /** Every hover/tooltip prop this component's own hover machinery reads — see {@link HoverConfig}. */
-        hover: HoverConfig<TData>;
-        /** Explicit `<Plot x>` override — bypasses `scales`-derived resolution (e.g. GeoPlot's fixed lon/lat domain). */
-        x?: false | import("svelteplot/types/data.js").RawValue[] | Partial<import("svelteplot/types/scale.js").XScaleOptions> | undefined;
-        /** Explicit `<Plot y>` override — see `x`. */
-        y?: false | import("svelteplot/types/data.js").RawValue[] | Partial<import("svelteplot/types/scale.js").YScaleOptions> | undefined;
-        /** Scale config `x`/`y` are derived from when not given directly. */
-        scales?: AxisBasedScalesConfig<TData>;
-        /** This plot kind's coordinate system config — `GeoPlot` only (a projection + pan/zoom). */
-        coordinates?: CoordinatesConfig;
-        /** Partial margin override — merged on top of the theme. */
-        margins?: MarginConfig;
-        /** Numeric fallback for a margin side that resolved to `'auto'` — see `numericMargin`'s doc comment. */
-        marginEstimate?: Record<"top" | "right" | "bottom" | "left", number>;
-        /**
-         * Forces svelteplot's own `<Plot>` to fully unmount/remount (via
-         * `{#key}`) whenever this changes, instead of reacting to a `margins`
-         * prop change on an already-mounted instance. Only needed by a caller
-         * (line's own `Plot.svelte`) whose `margins` grows *after* mount, from
-         * measuring rendered content (see `createLabelMarginTracker`) — handing
-         * svelteplot's `<Plot>` a live post-mount margin change (rather than the
-         * same final value from its very first mount) was observed to send its
-         * own internal auto-margin sizing into a permanent one-pixel
-         * bottom-margin oscillation for line's end-point value labels
-         * specifically, which in turn kept re-triggering the overflow watcher
-         * that grew the margin in the first place — an infinite effect loop
-         * that tripped Svelte's `effect_update_depth_exceeded` guard. A static
-         * `margins` prop (the common case — every other plot kind) never needs
-         * this; leave it unset there.
-         */
-        marginRemountKey?: string | number;
-        /** Boosts the bottom margin for a rotated x tick label — axis-having plot kinds only. */
-        xTickRotate?: number;
-        /** This plot kind's own `styles` prop, forwarded to the Styles layer. */
-        styles?: StylesLayoutConfig;
-        /**
-         * This plot kind's own markers array. Accepts a plain array, or a
-         * builder function for a plot kind whose own marker construction needs
-         * `setHoverMatch`/`clearHoverMatch`, only available once this
-         * component's own hover controller is set up.
-         */
-        markers?: MarkerConfig[] | ((hover: {
-            setHoverMatch: (rows: TData[]) => void;
-            clearHoverMatch: () => void;
-        }) => MarkerConfig[]);
-        /** All resolved series, forwarded to `GeometryLayout` — axis-based kinds only. Independently generic over `TSeries` (defaults to `TData`). */
-        seriesData?: Series<TSeries>[];
-        /** Per-series `GeometryLayout` groups — axis-based kinds only, same `TSeries` as `seriesData`. */
-        scopedGroups?: ScopedMarkerGroup<TSeries>[];
-        /** `GeoPlot`'s own untouched, tagged features, forwarded to `GeometryLayout` — `inset` marker only. */
-        geoAllFeatures?: (GeoFeature<Record<string, unknown>> & {
-            __id: string;
-        })[];
-        /** The wrapper div's own element — bind for a nested layout that needs it for its own gesture handling (e.g. `CoordinatesLayout`'s zoom/rotate). */
-        containerEl?: HTMLDivElement;
-        /**
-         * `matchedPoints` carries the source `row` alongside the display fields,
-         * so a template can resolve it straight off `row` instead of assuming
-         * which visual axis it landed on. `activePoint` is the one matched point
-         * under the cursor. `numericMargins` lets a nested layout align itself
-         * with the plot's own content box. `setHoverMatch`/`clearHoverMatch` let
-         * a plot kind drive the match itself instead of svelteplot's
-         * distance-based `<Pointer>` — see `hover.pointMatching`. When `markers`
-         * is given, this is `GeometryLayout`'s own `children` instead of raw
-         * plot content. Optional — a plot kind whose every mark is a `markers`
-         * entry has nothing left to render here.
-         */
-        children?: Snippet<[{
-            matchedPoints: HoverPoint<TData>[];
-            activePoint: HoverPoint<TData> | null;
-            impliesCrosshairX: boolean;
-            impliesCrosshairY: boolean;
-            numericMargins: {
-                top: number;
-                right: number;
-                bottom: number;
-                left: number;
-            };
-            setHoverMatch: (rows: TData[]) => void;
-            clearHoverMatch: () => void;
-        }]>;
-    };
-    exports: {};
-    bindings: "containerEl";
-    slots: {};
-    events: {};
-};
-declare class __sveltets_Render<TData extends Record<string, unknown>, TSeries extends Record<string, unknown> = TData> {
-    props(): ReturnType<typeof $$render<TData, TSeries>>['props'];
-    events(): ReturnType<typeof $$render<TData, TSeries>>['events'];
-    slots(): ReturnType<typeof $$render<TData, TSeries>>['slots'];
-    bindings(): "containerEl";
-    exports(): {};
-}
-interface $$IsomorphicComponent {
-    new <TData extends Record<string, unknown>, TSeries extends Record<string, unknown> = TData>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TData, TSeries>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TData, TSeries>['props']>, ReturnType<__sveltets_Render<TData, TSeries>['events']>, ReturnType<__sveltets_Render<TData, TSeries>['slots']>> & {
-        $$bindings?: ReturnType<__sveltets_Render<TData, TSeries>['bindings']>;
-    } & ReturnType<__sveltets_Render<TData, TSeries>['exports']>;
-    <TData extends Record<string, unknown>, TSeries extends Record<string, unknown> = TData>(internal: unknown, props: ReturnType<__sveltets_Render<TData, TSeries>['props']> & {}): ReturnType<__sveltets_Render<TData, TSeries>['exports']>;
-    z_$$bindings?: ReturnType<__sveltets_Render<any, any>['bindings']>;
-}
-declare const BasePlotLayout: $$IsomorphicComponent;
-type BasePlotLayout<TData extends Record<string, unknown>, TSeries extends Record<string, unknown> = TData> = InstanceType<typeof BasePlotLayout<TData, TSeries>>;
-export default BasePlotLayout;

package/dist/layout/plot/margins.d.ts

@@ -1,18 +0,0 @@
-export declare const AUTO_MARGIN_ESTIMATE: {
-    readonly top: 20;
-    readonly right: 20;
-    readonly bottom: 30;
-    readonly left: 40;
-};
-/**
- * Best-effort numeric fallback for a margin side that resolved to `'auto'`.
- * Used for layout heuristics that need *a* number before svelteplot has
- * measured the real rendered content (tick labels, axis title) — e.g.
- * capping tick count, or estimating a band's pixel width for the bar plot's
- * 'grouped' series layout. Not exact: an `'auto'` side can end up wider than
- * this once svelteplot measures unusually long tick labels.
- *
- * `estimate` defaults to `AUTO_MARGIN_ESTIMATE`; pass `GEO_MARGIN_ESTIMATE`
- * for GeoPlot, which has no axes for that estimate's asymmetry to apply to.
- */
-export declare function numericMargin(side: keyof typeof AUTO_MARGIN_ESTIMATE, value: number | 'auto' | undefined, estimate?: Record<keyof typeof AUTO_MARGIN_ESTIMATE, number>): number;

package/dist/layout/plot/margins.js

@@ -1,15 +0,0 @@
-export const AUTO_MARGIN_ESTIMATE = { top: 20, right: 20, bottom: 30, left: 40 };
-/**
- * Best-effort numeric fallback for a margin side that resolved to `'auto'`.
- * Used for layout heuristics that need *a* number before svelteplot has
- * measured the real rendered content (tick labels, axis title) — e.g.
- * capping tick count, or estimating a band's pixel width for the bar plot's
- * 'grouped' series layout. Not exact: an `'auto'` side can end up wider than
- * this once svelteplot measures unusually long tick labels.
- *
- * `estimate` defaults to `AUTO_MARGIN_ESTIMATE`; pass `GEO_MARGIN_ESTIMATE`
- * for GeoPlot, which has no axes for that estimate's asymmetry to apply to.
- */
-export function numericMargin(side, value, estimate = AUTO_MARGIN_ESTIMATE) {
-    return typeof value === 'number' ? value : estimate[side];
-}

package/dist/layout/plot/measureText.d.ts

@@ -1,4 +0,0 @@
-/** Pixel width of `text` set in `font` (a canvas font shorthand, e.g. `"14px sans-serif"`). 0 during SSR. */
-export declare function measureTextWidth(text: string, font: string): number;
-/** Widest of `labels` set in `font`. 0 for an empty list. */
-export declare function measureMaxLabelWidth(labels: string[], font: string): number;

package/dist/layout/plot/measureText.js

@@ -1,19 +0,0 @@
-let measureCtx;
-function getMeasureContext() {
-    if (measureCtx !== undefined)
-        return measureCtx;
-    measureCtx = typeof document === 'undefined' ? null : document.createElement('canvas').getContext('2d');
-    return measureCtx;
-}
-/** Pixel width of `text` set in `font` (a canvas font shorthand, e.g. `"14px sans-serif"`). 0 during SSR. */
-export function measureTextWidth(text, font) {
-    const ctx = getMeasureContext();
-    if (!ctx)
-        return 0;
-    ctx.font = font;
-    return ctx.measureText(text).width;
-}
-/** Widest of `labels` set in `font`. 0 for an empty list. */
-export function measureMaxLabelWidth(labels, font) {
-    return labels.reduce((max, label) => Math.max(max, measureTextWidth(label, font)), 0);
-}

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

@@ -1,25 +0,0 @@
-import type { AxisValue, AxisScale } from '../../types/layout/scales';
-/**
- * Resolves an author-facing {@link AxisScale} into what svelteplot's
- * `<Plot x>`/`<Plot y>` accepts — strips `grid`/`seriesLayout`/
- * `seriesPadding`/a vertical `label`, since `ScalesLayout` renders those
- * itself. Also defaults `nice: true` whenever the caller hasn't pinned a
- * `domain`/`ticks`/`nice`/non-numeric `type` of their own and the axis's own
- * values are plainly numeric ({@link isNumericAxis}), so an unpinned
- * continuous axis rounds its domain outward to whole tick steps instead of
- * stopping exactly at the data's own min/max.
- *
- * Deliberately *not* our own `[min, max]` padding: svelteplot computes the
- * real domain from every mark's own channels — e.g. a bar's implicit zero
- * baseline, or a stacked series' cumulative total — not just this axis's raw
- * per-row values, which is all this function has to work with. `nice`'s
- * domain-widening runs *after* that real domain is resolved, inside
- * svelteplot itself, so it stays correct for every plot kind for free — at
- * the cost of only widening up to the nearest round tick step, which can
- * still land exactly on the data's own min/max rather than strictly beyond
- * it (e.g. a value of exactly `52` needs no widening to reach the nice tick
- * `52`). Recomputing the domain ourselves to close that gap would need each
- * axis's true rendered extent (baseline/stack included), which only the
- * calling plot kind knows — not attempted here.
- */
-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,90 +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 this axis's own values are plainly numeric — required before
- * defaulting `nice: true`. Not just an optimization: svelteplot's own type
- * *inference* treats a `nice` option as a hint to resolve the scale as
- * `'linear'` (see its `autoScales.js`), so setting it on a scale whose real
- * values are strings (a bar/pyramid's category axis) would force a linear
- * scale onto categorical data and break the mark entirely.
- */
-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;
-}
-/**
- * Resolves an author-facing {@link AxisScale} into what svelteplot's
- * `<Plot x>`/`<Plot y>` accepts — strips `grid`/`seriesLayout`/
- * `seriesPadding`/a vertical `label`, since `ScalesLayout` renders those
- * itself. Also defaults `nice: true` whenever the caller hasn't pinned a
- * `domain`/`ticks`/`nice`/non-numeric `type` of their own and the axis's own
- * values are plainly numeric ({@link isNumericAxis}), so an unpinned
- * continuous axis rounds its domain outward to whole tick steps instead of
- * stopping exactly at the data's own min/max.
- *
- * Deliberately *not* our own `[min, max]` padding: svelteplot computes the
- * real domain from every mark's own channels — e.g. a bar's implicit zero
- * baseline, or a stacked series' cumulative total — not just this axis's raw
- * per-row values, which is all this function has to work with. `nice`'s
- * domain-widening runs *after* that real domain is resolved, inside
- * svelteplot itself, so it stays correct for every plot kind for free — at
- * the cost of only widening up to the nearest round tick step, which can
- * still land exactly on the data's own min/max rather than strictly beyond
- * it (e.g. a value of exactly `52` needs no widening to reach the nice tick
- * `52`). Recomputing the domain ourselves to close that gap would need each
- * axis's true rendered extent (baseline/stack included), which only the
- * calling plot kind knows — not attempted here.
- */
-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);
-    if (!sorted && !wantsNice)
-        return sorted;
-    const out = { ...sorted };
-    delete out.grid;
-    delete out.seriesLayout;
-    delete out.seriesPadding;
-    if (scale?.labelOrientation === 'vertical')
-        delete out.label;
-    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];