matterviz 0.3.6 → 0.3.7

package/dist/plot/data-transform.d.ts

@@ -0,0 +1,16 @@
+import type { D3SymbolName } from '../labels';
+import type { DataSeries, Point } from './';
+export declare const get_series_color: (series_idx: number) => string;
+export declare const get_series_symbol: (series_idx: number) => D3SymbolName;
+export declare const extract_series_color: (series_data: DataSeries) => string;
+export declare const prepare_legend_data: (series: DataSeries[]) => {
+    series_idx: number;
+    label: string;
+    visible: boolean;
+    display_style: {
+        symbol_type: D3SymbolName;
+        symbol_color: string;
+    };
+}[];
+export declare const create_data_points: (series: DataSeries[], filter_fn?: (series: DataSeries) => boolean) => Point[];
+export declare function process_prop<T>(prop: T[] | T | undefined | null, idx: number): T | undefined;

package/dist/plot/data-transform.js

@@ -0,0 +1,45 @@
+import { DEFAULT_SERIES_COLORS, DEFAULT_SERIES_SYMBOLS } from './types';
+import { DEFAULTS } from '../settings';
+// Get auto-cycling color for series at given index (wraps every 10)
+export const get_series_color = (series_idx) => DEFAULT_SERIES_COLORS[series_idx % DEFAULT_SERIES_COLORS.length];
+// Get auto-cycling symbol for series at given index (wraps every 7)
+export const get_series_symbol = (series_idx) => DEFAULT_SERIES_SYMBOLS[series_idx % DEFAULT_SERIES_SYMBOLS.length];
+// Extract the primary color from a series data object.
+// Checks line stroke, then point fill (handling arrays), with fallback to default blue.
+export const extract_series_color = (series_data) => series_data.line_style?.stroke ||
+    (Array.isArray(series_data.point_style)
+        ? series_data.point_style[0]?.fill
+        : series_data.point_style?.fill) ||
+    `#4A9EFF`;
+// Prepare legend data from series array
+export const prepare_legend_data = (series) => series.map((series_data, series_idx) => ({
+    series_idx,
+    label: series_data.label ?? `Series ${series_idx + 1}`,
+    visible: series_data.visible ?? true,
+    display_style: {
+        // Prefer the series’ symbol when present, falling back to settings
+        symbol_type: !Array.isArray(series_data.point_style)
+            ? (series_data.point_style?.symbol_type ?? DEFAULTS.scatter.symbol_type)
+            : DEFAULTS.scatter.symbol_type,
+        symbol_color: extract_series_color(series_data),
+    },
+}));
+// Create data points from series for analysis
+export const create_data_points = (series, filter_fn) => series
+    .filter(filter_fn ?? ((srs) => srs.visible ?? true))
+    .flatMap(({ x: xs, y: ys }, series_idx) => {
+    const length = Math.min(xs.length, ys.length);
+    if (xs.length !== ys.length) {
+        console.warn(`length mismatch in series ${series_idx}: x.length=${xs.length} vs y.length=${ys.length}`);
+    }
+    return xs.slice(0, length).map((x, idx) => ({ x, y: ys[idx] }));
+});
+// Process array or scalar properties for indexed access.
+// If prop is an array, returns the element at the given index.
+// If prop is a scalar, returns the scalar (applied to all indices).
+// Returns undefined if prop is null/undefined.
+export function process_prop(prop, idx) {
+    if (prop == null)
+        return undefined;
+    return Array.isArray(prop) ? prop[idx] : prop;
+}

package/dist/plot/defaults.d.ts

@@ -0,0 +1,19 @@
+export declare const AXIS_DEFAULTS: {
+    format: string;
+    scale_type: "linear";
+    ticks: number;
+    label_shift: {
+        x: number;
+        y: number;
+    };
+    tick: {
+        label: {
+            shift: {
+                x: number;
+                y: number;
+            };
+            inside: boolean;
+        };
+    };
+    range: [number | null, number | null];
+};

package/dist/plot/defaults.js

@@ -0,0 +1,9 @@
+// Shared axis defaults across plot components (single source of truth)
+export const AXIS_DEFAULTS = {
+    format: ``,
+    scale_type: `linear`,
+    ticks: 5,
+    label_shift: { x: 0, y: 0 },
+    tick: { label: { shift: { x: 0, y: 0 }, inside: false } },
+    range: [null, null],
+};

package/dist/plot/fill-utils.d.ts

@@ -0,0 +1,46 @@
+import type { DataSeries, ErrorBand, FillBoundary, FillCurveType, FillGradient, FillRegion, ScaleType } from './types';
+export declare const LOG_EPSILON = 1e-10;
+export interface FillPathPoint {
+    x: number;
+    y1: number;
+    y2: number;
+}
+type FillPathArrays = Record<keyof FillPathPoint, number[]>;
+export interface InterpolatedSeries {
+    x: number[];
+    y_a: number[];
+    y_b: number[];
+}
+export interface FilteredFillData extends FillPathArrays {
+    original_indices: number[];
+}
+export interface ConditionedFillData {
+    segments: FillPathPoint[][];
+}
+export interface ClampedFillData extends FillPathArrays {
+    clamped_indices: number[];
+}
+export declare function resolve_series_ref(ref: {
+    type: `series`;
+    series_idx?: number;
+    series_id?: string | number;
+}, series: readonly DataSeries[]): DataSeries | null;
+export declare function interpolate_series(series_a: {
+    x: readonly number[];
+    y: readonly number[];
+}, series_b: {
+    x: readonly number[];
+    y: readonly number[];
+}, method?: `linear` | `step`): InterpolatedSeries;
+interface DomainContext {
+    y_domain: [number, number];
+    y2_domain?: [number, number];
+}
+export declare function resolve_boundary(boundary: FillBoundary, series: readonly DataSeries[], x_values: readonly number[], domains: DomainContext): number[] | null;
+export declare function apply_range_constraints(x_values: readonly number[], y1_values: readonly number[], y2_values: readonly number[], region: Pick<FillRegion, `x_range` | `y_range`>): FilteredFillData;
+export declare function apply_where_condition(x_values: readonly number[], y1_values: readonly number[], y2_values: readonly number[], region: Pick<FillRegion, `where`>): ConditionedFillData;
+export declare function clamp_for_log_scale(x_values: readonly number[], y1_values: readonly number[], y2_values: readonly number[], y_scale_type: ScaleType, x_scale_type?: ScaleType): ClampedFillData;
+export declare function generate_fill_path(data: readonly FillPathPoint[], curve_type?: FillCurveType): string;
+export declare function convert_error_band_to_fill_region(error_band: ErrorBand, series: readonly DataSeries[], default_color?: string): FillRegion | null;
+export declare const is_fill_gradient: (fill: string | FillGradient | undefined) => fill is FillGradient;
+export {};

package/dist/plot/fill-utils.js

@@ -0,0 +1,322 @@
+// Fill-between utility functions for ScatterPlot fill regions
+// Handles interpolation, boundary resolution, and path generation
+import { area, curveBasis, curveCardinal, curveCatmullRom, curveLinear, curveMonotoneX, curveMonotoneY, curveNatural, curveStep, curveStepAfter, curveStepBefore, } from 'd3-shape';
+// Epsilon value for log scale clamping (to avoid log(0) = -Infinity)
+export const LOG_EPSILON = 1e-10;
+// Resolves a series reference (by index or id) to the actual DataSeries
+// Returns null if the reference cannot be resolved
+export function resolve_series_ref(ref, series) {
+    if (`series_idx` in ref && typeof ref.series_idx === `number`) {
+        const idx = ref.series_idx;
+        if (idx >= 0 && idx < series.length) {
+            return series[idx];
+        }
+        return null;
+    }
+    if (`series_id` in ref && ref.series_id !== undefined) {
+        const found = series.find((data_series) => data_series.id === ref.series_id);
+        return found ?? null;
+    }
+    return null;
+}
+// Helper: linear interpolation at a specific x value
+function interpolate_at(x_values, y_values, target_x) {
+    // Find bracketing indices
+    let [left_idx, right_idx] = [-1, -1];
+    for (let idx = 0; idx < x_values.length; idx++) {
+        if (x_values[idx] <= target_x)
+            left_idx = idx;
+        if (x_values[idx] >= target_x && right_idx === -1)
+            right_idx = idx;
+    }
+    // Handle edge cases: exact match, before all, after all
+    if (left_idx >= 0 && x_values[left_idx] === target_x)
+        return y_values[left_idx];
+    if (left_idx === -1)
+        return y_values[0];
+    if (right_idx === -1)
+        return y_values[y_values.length - 1];
+    // Linear interpolation
+    const x_left = x_values[left_idx];
+    const x_right = x_values[right_idx];
+    const y_left = y_values[left_idx];
+    const y_right = y_values[right_idx];
+    return x_right === x_left
+        ? y_left
+        : y_left + ((target_x - x_left) / (x_right - x_left)) * (y_right - y_left);
+}
+// Helper: step interpolation at a specific x value
+function step_interpolate_at(x_values, y_values, target_x) {
+    // Find the last x value <= target_x
+    let last_idx = -1;
+    for (let idx = 0; idx < x_values.length; idx++) {
+        if (x_values[idx] <= target_x)
+            last_idx = idx;
+        else
+            break;
+    }
+    // Before all x values, use first y value
+    if (last_idx === -1)
+        return y_values[0];
+    return y_values[last_idx];
+}
+// Interpolates two series to have matching x-values
+// Returns arrays with the union of all x-values, sorted
+export function interpolate_series(series_a, series_b, method = `linear`) {
+    // Create union of x-values
+    const x_set = new Set();
+    for (const curr_x of series_a.x)
+        x_set.add(curr_x);
+    for (const curr_x of series_b.x)
+        x_set.add(curr_x);
+    // Sort x-values
+    const all_x = Array.from(x_set).sort((val_a, val_b) => val_a - val_b);
+    const interpolate_fn = method === `step` ? step_interpolate_at : interpolate_at;
+    // Interpolate y values for each x
+    const y_a = all_x.map((target_x) => interpolate_fn(series_a.x, series_a.y, target_x));
+    const y_b = all_x.map((target_x) => interpolate_fn(series_b.x, series_b.y, target_x));
+    return { x: all_x, y_a, y_b };
+}
+// Resolves a FillBoundary definition to an array of y-values at given x positions
+// Returns null if the boundary cannot be resolved
+export function resolve_boundary(boundary, series, x_values, domains) {
+    // Handle shorthand number (constant value)
+    if (typeof boundary === `number`) {
+        return x_values.map(() => boundary);
+    }
+    if (boundary.type === `series`) {
+        const resolved = resolve_series_ref(boundary, series);
+        if (!resolved)
+            return null;
+        // Interpolate to match x_values
+        const interpolated = interpolate_series({ x: x_values, y: x_values.map(() => 0) }, { x: resolved.x, y: resolved.y }, `linear`);
+        return interpolated.y_b;
+    }
+    if (boundary.type === `constant`)
+        return x_values.map(() => boundary.value);
+    if (boundary.type === `axis`) {
+        // For axis boundaries, return the edge value of the appropriate axis domain
+        const value = boundary.value ??
+            (boundary.axis === `y2` ? domains.y2_domain?.[0] : undefined) ??
+            domains.y_domain[0];
+        return x_values.map(() => value);
+    }
+    if (boundary.type === `function`)
+        return x_values.map((curr_x) => boundary.fn(curr_x));
+    if (boundary.type === `data`) {
+        if (boundary.values.length === 0)
+            return Array(x_values.length).fill(NaN);
+        // If lengths match, use directly; otherwise interpolate
+        if (boundary.values.length === x_values.length)
+            return [...boundary.values];
+        // Lengths don't match: truncate if values is longer, or extend last value if shorter
+        return x_values.map((_, idx) => boundary.values[idx] ?? boundary.values[boundary.values.length - 1]);
+    }
+    return null;
+}
+export function apply_range_constraints(x_values, y1_values, y2_values, region) {
+    const [x_min, x_max] = region.x_range ?? [null, null];
+    const [y_min, y_max] = region.y_range ?? [null, null];
+    // Helper to clamp value within optional bounds
+    const clamp = (val) => Math.min(y_max ?? Infinity, Math.max(y_min ?? -Infinity, val));
+    const result = {
+        x: [],
+        y1: [],
+        y2: [],
+        original_indices: [],
+    };
+    for (let idx = 0; idx < x_values.length; idx++) {
+        const [curr_x, curr_y1, curr_y2] = [x_values[idx], y1_values[idx], y2_values[idx]];
+        // Skip if outside x range
+        if ((x_min !== null && curr_x < x_min) || (x_max !== null && curr_x > x_max))
+            continue;
+        // Skip if fill region doesn't overlap y range
+        const [fill_min, fill_max] = [Math.min(curr_y1, curr_y2), Math.max(curr_y1, curr_y2)];
+        if ((y_min !== null && fill_max < y_min) || (y_max !== null && fill_min > y_max)) {
+            continue;
+        }
+        result.x.push(curr_x);
+        result.y1.push(clamp(curr_y1));
+        result.y2.push(clamp(curr_y2));
+        result.original_indices.push(idx);
+    }
+    return result;
+}
+// Helper: find x-coordinate where condition changes (linear interpolation)
+function find_crossing(x1, y1_upper, y1_lower, x2, y2_upper, y2_lower, condition) {
+    const cond1 = condition(x1, y1_upper, y1_lower);
+    const cond2 = condition(x2, y2_upper, y2_lower);
+    if (cond1 === cond2)
+        return null;
+    // Binary search for crossing point
+    let left = x1;
+    let right = x2;
+    const tolerance = (x2 - x1) * 0.001;
+    for (let iter = 0; iter < 20; iter++) {
+        const mid = (left + right) / 2;
+        const weight = (mid - x1) / (x2 - x1);
+        const mid_upper = y1_upper + weight * (y2_upper - y1_upper);
+        const mid_lower = y1_lower + weight * (y2_lower - y1_lower);
+        const mid_cond = condition(mid, mid_upper, mid_lower);
+        if (mid_cond === cond1) {
+            left = mid;
+        }
+        else {
+            right = mid;
+        }
+        if (right - left < tolerance)
+            break;
+    }
+    return (left + right) / 2;
+}
+export function apply_where_condition(x_values, y1_values, y2_values, region) {
+    if (!region.where) {
+        // No condition - return single segment with all points
+        const points = x_values.map((curr_x, idx) => ({
+            x: curr_x,
+            y1: y1_values[idx],
+            y2: y2_values[idx],
+        }));
+        return { segments: [points] };
+    }
+    const segments = [];
+    let current_segment = [];
+    for (let idx = 0; idx < x_values.length; idx++) {
+        const curr_x = x_values[idx];
+        const curr_y1 = y1_values[idx];
+        const curr_y2 = y2_values[idx];
+        const passes = region.where(curr_x, curr_y1, curr_y2);
+        if (idx > 0) {
+            const prev_x = x_values[idx - 1];
+            const prev_y1 = y1_values[idx - 1];
+            const prev_y2 = y2_values[idx - 1];
+            const prev_passes = region.where(prev_x, prev_y1, prev_y2);
+            // Check for condition crossing between prev and current
+            if (passes !== prev_passes) {
+                const crossing_x = find_crossing(prev_x, prev_y1, prev_y2, curr_x, curr_y1, curr_y2, region.where);
+                if (crossing_x !== null) {
+                    // Interpolate y values at crossing point
+                    const weight = (crossing_x - prev_x) / (curr_x - prev_x);
+                    const crossing_y1 = prev_y1 + weight * (curr_y1 - prev_y1);
+                    const crossing_y2 = prev_y2 + weight * (curr_y2 - prev_y2);
+                    if (prev_passes) {
+                        // End current segment at crossing
+                        current_segment.push({ x: crossing_x, y1: crossing_y1, y2: crossing_y2 });
+                        segments.push(current_segment);
+                        current_segment = [];
+                    }
+                    else {
+                        // Start new segment at crossing
+                        current_segment.push({ x: crossing_x, y1: crossing_y1, y2: crossing_y2 });
+                    }
+                }
+            }
+        }
+        if (passes) {
+            current_segment.push({ x: curr_x, y1: curr_y1, y2: curr_y2 });
+        }
+        else if (current_segment.length > 0) {
+            segments.push(current_segment);
+            current_segment = [];
+        }
+    }
+    // Don't forget the last segment
+    if (current_segment.length > 0) {
+        segments.push(current_segment);
+    }
+    return { segments };
+}
+export function clamp_for_log_scale(x_values, y1_values, y2_values, y_scale_type, x_scale_type = `linear`) {
+    const result_x = [];
+    const result_y1 = [];
+    const result_y2 = [];
+    const clamped_indices = [];
+    for (let idx = 0; idx < x_values.length; idx++) {
+        let curr_x = x_values[idx];
+        let curr_y1 = y1_values[idx];
+        let curr_y2 = y2_values[idx];
+        let was_clamped = false;
+        // Clamp x if x-axis is log scale
+        if (x_scale_type === `log` && curr_x <= 0) {
+            curr_x = LOG_EPSILON;
+            was_clamped = true;
+        }
+        // Clamp y values if y-axis is log scale
+        if (y_scale_type === `log`) {
+            if (curr_y1 <= 0) {
+                curr_y1 = LOG_EPSILON;
+                was_clamped = true;
+            }
+            if (curr_y2 <= 0) {
+                curr_y2 = LOG_EPSILON;
+                was_clamped = true;
+            }
+        }
+        result_x.push(curr_x);
+        result_y1.push(curr_y1);
+        result_y2.push(curr_y2);
+        if (was_clamped) {
+            clamped_indices.push(idx);
+        }
+    }
+    return {
+        x: result_x,
+        y1: result_y1,
+        y2: result_y2,
+        clamped_indices,
+    };
+}
+// Map FillCurveType to d3 curve factory
+const CURVE_MAP = {
+    linear: curveLinear,
+    monotoneX: curveMonotoneX,
+    monotoneY: curveMonotoneY,
+    step: curveStep,
+    stepBefore: curveStepBefore,
+    stepAfter: curveStepAfter,
+    basis: curveBasis,
+    cardinal: curveCardinal,
+    catmullRom: curveCatmullRom,
+    natural: curveNatural,
+};
+const get_curve = (curve_type) => CURVE_MAP[curve_type] ?? curveMonotoneX;
+// Generate SVG path string for a fill region
+// data should already be in pixel coordinates
+export function generate_fill_path(data, curve_type = `monotoneX`) {
+    if (data.length === 0)
+        return ``;
+    const curve = get_curve(curve_type);
+    const area_generator = area()
+        .x((point) => point.x)
+        .y0((point) => point.y1)
+        .y1((point) => point.y2)
+        .curve(curve);
+    return area_generator(data) ?? ``;
+}
+// Helper to expand error definition to array
+const expand_error = (err, length) => typeof err === `number` ? Array(length).fill(err) : err;
+// Convert an ErrorBand convenience type to a full FillRegion
+export function convert_error_band_to_fill_region(error_band, series, default_color) {
+    const resolved = resolve_series_ref(error_band.series, series);
+    if (!resolved)
+        return null;
+    const { y } = resolved;
+    const { error } = error_band;
+    // Determine upper/lower error arrays
+    const [upper_err, lower_err] = typeof error === `object` && `upper` in error
+        ? [expand_error(error.upper, y.length), expand_error(error.lower, y.length)]
+        : [expand_error(error, y.length), expand_error(error, y.length)];
+    return {
+        id: error_band.id,
+        label: error_band.label,
+        upper: { type: `data`, values: y.map((val, idx) => val + upper_err[idx]) },
+        lower: { type: `data`, values: y.map((val, idx) => val - lower_err[idx]) },
+        fill: error_band.fill ?? default_color ?? `#4e79a7`,
+        fill_opacity: error_band.fill_opacity ?? 0.3,
+        edge_upper: error_band.edge_style,
+        edge_lower: error_band.edge_style,
+        show_in_legend: error_band.show_in_legend ?? true,
+    };
+}
+// Type guard to check if fill is a gradient
+export const is_fill_gradient = (fill) => typeof fill === `object` && fill !== null && `type` in fill && `stops` in fill;

package/dist/plot/hover-lock.svelte.d.ts

@@ -0,0 +1,14 @@
+export declare const HOVER_DEBOUNCE_MS = 300;
+interface ReactiveBoolean {
+    readonly current: boolean;
+}
+export declare function create_hover_lock(): {
+    is_locked: ReactiveBoolean;
+    set_locked: (locked: boolean) => void;
+    cleanup: () => void;
+};
+export declare function create_dimension_tracker(): {
+    has_changed: (width: number, height: number) => boolean;
+    update: (width: number, height: number) => void;
+};
+export {};

package/dist/plot/hover-lock.svelte.js

@@ -0,0 +1,46 @@
+// Shared utility for hover lock behavior on plot elements (legend, colorbar)
+// Prevents element repositioning while user is hovering, with debounced release
+export const HOVER_DEBOUNCE_MS = 300;
+// Creates hover lock state and handlers for a plot element
+export function create_hover_lock() {
+    let is_locked = $state(false);
+    let timeout = null;
+    // Stable object reference with getter - Svelte tracks the getter read
+    const locked_ref = {
+        get current() {
+            return is_locked;
+        },
+    };
+    return {
+        is_locked: locked_ref,
+        set_locked(locked) {
+            if (locked) {
+                if (timeout)
+                    clearTimeout(timeout);
+                is_locked = true;
+            }
+            else {
+                timeout = setTimeout(() => (is_locked = false), HOVER_DEBOUNCE_MS);
+            }
+        },
+        // Clear pending timeout to prevent state updates after unmount
+        cleanup() {
+            if (timeout)
+                clearTimeout(timeout);
+        },
+    };
+}
+// Tracks previous dimensions for resize detection
+export function create_dimension_tracker() {
+    let prev = $state(null);
+    return {
+        has_changed(width, height) {
+            if (!prev)
+                return true;
+            return prev.width !== width || prev.height !== height;
+        },
+        update(width, height) {
+            prev = { width, height };
+        },
+    };
+}

package/dist/plot/index.d.ts

@@ -0,0 +1,41 @@
+export { default as AxisLabel } from './AxisLabel.svelte';
+export { default as BarPlot } from './BarPlot.svelte';
+export { default as BarPlotControls } from './BarPlotControls.svelte';
+export { default as ColorBar } from './ColorBar.svelte';
+export { default as BinnedScatterPlot } from './BinnedScatterPlot.svelte';
+export type { BinnedColorScaleConfig, BinnedDensityConfig, BinnedOverlaysConfig, BinnedPointBasePayload, BinnedPointDataFn, BinnedPointLabelPlacementConfig, BinnedPointLabelsConfig, BinnedPointPayload, BinnedPointTooltipPayload, BinnedRefLine, BinnedSizeScaleConfig, } from './binned-scatter-types';
+export type { DensePointSeries } from './adaptive-density';
+export { default as PlotAxis } from './PlotAxis.svelte';
+export { default as ColorScaleSelect } from './ColorScaleSelect.svelte';
+export * from './data-cleaning';
+export { default as ElementScatter } from './ElementScatter.svelte';
+export * from './fill-utils';
+export { default as FillArea } from './FillArea.svelte';
+export { default as Histogram } from './Histogram.svelte';
+export { default as HistogramControls } from './HistogramControls.svelte';
+export * from './interactions';
+export { default as InteractiveAxisLabel } from './InteractiveAxisLabel.svelte';
+export * from './layout';
+export { default as Line } from './Line.svelte';
+export { default as PlotControls } from './PlotControls.svelte';
+export { default as PlotLegend } from './PlotLegend.svelte';
+export { default as PlotTooltip } from './PlotTooltip.svelte';
+export { default as PortalSelect } from './PortalSelect.svelte';
+export * from './reference-line';
+export { default as ReferenceLine } from './ReferenceLine.svelte';
+export { default as ReferenceLine3D } from './ReferenceLine3D.svelte';
+export { default as ReferencePlane } from './ReferencePlane.svelte';
+export * from './scales';
+export { default as ScatterPlot } from './ScatterPlot.svelte';
+export { default as ScatterPlot3D } from './ScatterPlot3D.svelte';
+export { default as ScatterPlot3DControls } from './ScatterPlot3DControls.svelte';
+export { default as ScatterPlot3DScene } from './ScatterPlot3DScene.svelte';
+export { default as ScatterPlotControls } from './ScatterPlotControls.svelte';
+export { default as ScatterPoint } from './ScatterPoint.svelte';
+export { default as SpacegroupBarPlot } from './SpacegroupBarPlot.svelte';
+export { default as Surface3D } from './Surface3D.svelte';
+export * from './svg';
+export * from './types';
+export * from './utils';
+export { default as ZeroLines } from './ZeroLines.svelte';
+export { default as ZoomRect } from './ZoomRect.svelte';

package/dist/plot/index.js

@@ -0,0 +1,39 @@
+export { default as AxisLabel } from './AxisLabel.svelte';
+export { default as BarPlot } from './BarPlot.svelte';
+export { default as BarPlotControls } from './BarPlotControls.svelte';
+export { default as ColorBar } from './ColorBar.svelte';
+export { default as BinnedScatterPlot } from './BinnedScatterPlot.svelte';
+export { default as PlotAxis } from './PlotAxis.svelte';
+export { default as ColorScaleSelect } from './ColorScaleSelect.svelte';
+export * from './data-cleaning';
+export { default as ElementScatter } from './ElementScatter.svelte';
+export * from './fill-utils';
+export { default as FillArea } from './FillArea.svelte';
+export { default as Histogram } from './Histogram.svelte';
+export { default as HistogramControls } from './HistogramControls.svelte';
+export * from './interactions';
+export { default as InteractiveAxisLabel } from './InteractiveAxisLabel.svelte';
+export * from './layout';
+export { default as Line } from './Line.svelte';
+export { default as PlotControls } from './PlotControls.svelte';
+export { default as PlotLegend } from './PlotLegend.svelte';
+export { default as PlotTooltip } from './PlotTooltip.svelte';
+export { default as PortalSelect } from './PortalSelect.svelte';
+export * from './reference-line';
+export { default as ReferenceLine } from './ReferenceLine.svelte';
+export { default as ReferenceLine3D } from './ReferenceLine3D.svelte';
+export { default as ReferencePlane } from './ReferencePlane.svelte';
+export * from './scales';
+export { default as ScatterPlot } from './ScatterPlot.svelte';
+export { default as ScatterPlot3D } from './ScatterPlot3D.svelte';
+export { default as ScatterPlot3DControls } from './ScatterPlot3DControls.svelte';
+export { default as ScatterPlot3DScene } from './ScatterPlot3DScene.svelte';
+export { default as ScatterPlotControls } from './ScatterPlotControls.svelte';
+export { default as ScatterPoint } from './ScatterPoint.svelte';
+export { default as SpacegroupBarPlot } from './SpacegroupBarPlot.svelte';
+export { default as Surface3D } from './Surface3D.svelte';
+export * from './svg';
+export * from './types';
+export * from './utils';
+export { default as ZeroLines } from './ZeroLines.svelte';
+export { default as ZoomRect } from './ZoomRect.svelte';

package/dist/plot/interactions.d.ts

@@ -0,0 +1,12 @@
+import type { Point2D, Vec2 } from '../math';
+import type { Y2SyncConfig, Y2SyncMode } from './types';
+export declare function get_relative_coords(evt: MouseEvent): Point2D | null;
+export declare function normalize_y2_sync(sync: Y2SyncConfig | Y2SyncMode | undefined): Y2SyncConfig;
+export declare function sync_y2_range(y1_range: Vec2, y2_base_range: Vec2, sync: Y2SyncConfig): Vec2;
+export declare const pan_range: (current: Vec2, delta: number) => Vec2;
+export declare function pixels_to_data_delta(pixel_delta: number, data_range: Vec2, pixel_range: number): number;
+export declare const PINCH_ZOOM_THRESHOLD = 0.1;
+export declare function expand_range_if_needed(current: Vec2, new_range: Vec2): {
+    range: Vec2;
+    changed: boolean;
+};